org.simantics.proconf.processeditor/src/org/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 org.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.viewers.ISelection;\r
  21 import org.eclipse.jface.viewers.ISelectionChangedListener;\r
  22 import org.eclipse.jface.viewers.SelectionChangedEvent;\r
  23 import org.eclipse.swt.widgets.Composite;\r
  24 import org.eclipse.ui.IWorkbenchPart;\r
  25 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;\r
  26 import org.simantics.db.Graph;\r
  27 import org.simantics.db.Resource;\r
  28 import org.simantics.db.Session;\r
  29 import org.simantics.db.management.ISessionContext;\r
  30 import org.simantics.layer0.utils.EntityFactory;\r
  31 import org.simantics.layer0.utils.IEntity;\r
  32 import org.simantics.layer0.utils.Property;\r
  33 import org.simantics.processeditor.Activator;\r
  34 import org.simantics.processeditor.ProcessResource;\r
  35 import org.simantics.processeditor.actions.InsertComponentAction;\r
  36 import org.simantics.processeditor.actions.InsertEquipmentAction;\r
  37 import org.simantics.processeditor.actions.InsertNozzleAction;\r
  38 import org.simantics.processeditor.actions.RoutePipeAction;\r
  39 import org.simantics.processeditor.common.ControlPointTools;\r
  40 import org.simantics.processeditor.common.PipingRules;\r
  41 import org.simantics.processeditor.dialogs.FloorConfigureDialog;\r
  42 import org.simantics.processeditor.scenegraph.NonVisibleNode;\r
  43 import org.simantics.processeditor.scenegraph.PipeComponentNode;\r
  44 import org.simantics.processeditor.scenegraph.PipeRunNode;\r
  45 import org.simantics.processeditor.scenegraph.PipelineComponentNode;\r
  46 import org.simantics.processeditor.stubs.PipeControlPoint;\r
  47 import org.simantics.processeditor.stubs.PipeRun;\r
  48 import org.simantics.processeditor.stubs.Plant;\r
  49 import org.simantics.processeditor.stubs.Plant3DResource;\r
  50 import org.simantics.processeditor.tools.PlantEditContribution;\r
  51 import org.simantics.processeditor.tools.PlantVisualizationContribution;\r
  52 import org.simantics.proconf.g3d.base.JmeRenderingComponent;\r
  53 import org.simantics.proconf.g3d.base.ScenegraphAdapter;\r
  54 import org.simantics.proconf.g3d.base.ScenegraphAdapterImpl;\r
  55 import org.simantics.proconf.g3d.base.SelectionAdapter;\r
  56 import org.simantics.proconf.g3d.base.ThreeDimensionalEditorBase;\r
  57 import org.simantics.proconf.g3d.common.StructuredResourceSelection;\r
  58 import org.simantics.proconf.g3d.scenegraph.IGeometryNode;\r
  59 import org.simantics.proconf.g3d.scenegraph.IGraphicsNode;\r
  60 import org.simantics.proconf.g3d.scenegraph.ISelectableNode;\r
  61 import org.simantics.proconf.g3d.scenegraph.ParameterizedModelNode;\r
  62 import org.simantics.proconf.g3d.shapes.FloorShape;\r
  63 import org.simantics.proconf.g3d.stubs.G3DNode;\r
  64 import org.simantics.utils.ui.ErrorLogger;\r
  65 import org.simantics.utils.ui.jface.MenuTools;\r
  66 \r
  67 import com.jme.math.Vector3f;\r
  68 import com.jme.scene.Geometry;\r
  69 \r
  70 \r
  71 public class ProcessEditor extends ThreeDimensionalEditorBase {\r
  72     \r
  73     private Resource plantResource = null;\r
  74     \r
  75     private Action configureFloorAction = null;\r
  76 \r
  77     private Geometry floorShape = null;\r
  78 \r
  79     public ProcessEditor(ISessionContext session) {\r
  80         super(session);\r
  81         addEditorContribution(new PlantEditContribution(this));\r
  82         addEditorContribution(new PlantVisualizationContribution(this));\r
  83     }\r
  84     \r
  85     public ProcessEditor(ISessionContext session,JmeRenderingComponent component) {\r
  86         super(session,component);\r
  87         addEditorContribution(new PlantEditContribution(this));\r
  88         addEditorContribution(new PlantVisualizationContribution(this));\r
  89     }\r
  90     \r
  91     @Override\r
  92     protected ScenegraphAdapter createScenegraphAdapter() {\r
  93         return new ProcessEditorAdapter(session,getRenderingComponent());\r
  94     }\r
  95     \r
  96     @Override\r
  97     public void createControl(Graph graph,Composite parent) {\r
  98         super.createControl(graph,parent);\r
  99 \r
 100         floorShape = FloorShape.getShape(getRenderingComponent().getDisplaySystem().getRenderer(), 100.f,0.2f);\r
 101         getRenderingComponent().getNoCastRoot().attachChild(floorShape);\r
 102         floorShape.setLocalTranslation(new Vector3f(0.f,-0.01f,0.f));\r
 103     }\r
 104 \r
 105     @Override\r
 106     protected void makeActions(Graph graph) {\r
 107         super.makeActions(graph);\r
 108 \r
 109         //actions.add(new ShowTrendsAction(this));\r
 110 \r
 111         configureFloorAction = new Action() {\r
 112                 public void run() {\r
 113                         FloorConfigureDialog dialog = new FloorConfigureDialog(ProcessEditor.this.parent.getShell());\r
 114                         if (dialog.open() == FloorConfigureDialog.CANCEL)\r
 115                                 return;\r
 116                         if (dialog.isFloorEnabled()) {\r
 117                                 if (floorShape.getParent() == null)\r
 118                                         getRenderingComponent().getNoCastRoot().attachChild(floorShape);\r
 119                         } else {\r
 120                                 floorShape.removeFromParent();\r
 121                         }\r
 122                         floorShape.setLocalTranslation(new Vector3f(0.f,(float)dialog.getFloorHeight(),0.f));\r
 123                         \r
 124                 }\r
 125         };\r
 126         configureFloorAction.setText("Configure floor");\r
 127         configureFloorAction.setImageDescriptor(Activator.imageDescriptorFromPlugin("fi.vtt.proconf.ode", "icons/silk/shape_align_bottom.png"));\r
 128 \r
 129 //        ContextActionFactory extended[] = ContextActionRegistry.getActions("fi.vtt.proconf.shapeeditor.processeditorview");\r
 130 //        for (ContextActionFactory c : extended) {\r
 131 //              actions.add(c.createAction(this));\r
 132 //        }\r
 133     }\r
 134     \r
 135     protected void fillLocalPullDown() {\r
 136         super.fillLocalPullDown();\r
 137         MenuTools.getOrCreate(getMenuID(),"Advanced", menuManager).add(configureFloorAction);\r
 138     }\r
 139     \r
 140     protected class ProcessEditorAdapter extends ScenegraphAdapterImpl {\r
 141         \r
 142          public ProcessEditorAdapter(Session session, JmeRenderingComponent component) {\r
 143                         super(session, component);\r
 144          }\r
 145          \r
 146          private class NormalScenegraphQuery extends ScenegraphQuery {\r
 147                 \r
 148                 public NormalScenegraphQuery(Resource node) {\r
 149                                 super(node);\r
 150                         } \r
 151                  \r
 152                  \r
 153                  @Override\r
 154                 public void shapeAdded(Graph graph, IGraphicsNode node) {\r
 155                          // FIXME : this won't work like in previous ProConf\r
 156                 }\r
 157          }\r
 158          \r
 159          private Map<Resource,PipeRunControlPointQuery> pipeRunQueries = new HashMap<Resource, PipeRunControlPointQuery>();\r
 160 \r
 161                 protected ScenegraphQuery newSubnodeListener(G3DNode node) {\r
 162                 if (node.isInstanceOf(ProcessResource.plant3Dresource.PipeRun)) {\r
 163                     PipeRunControlPointQuery query = new PipeRunControlPointQuery(node.getResource());\r
 164                     pipeRunQueries.put(node.getResource(), query);\r
 165                     node.getGraph().performQuery(query);\r
 166                 }\r
 167                 return new NormalScenegraphQuery(node.getResource());\r
 168                  \r
 169             }\r
 170                 \r
 171                 @Override\r
 172                 protected NodePropertyQuery newRootPropertyListener(G3DNode root) {\r
 173                         // currently Plant does not have any properties.\r
 174                         return null;\r
 175                 }\r
 176                 \r
 177                 private class TransformationQuery extends NodeTransformationQuery {\r
 178                         \r
 179                         public TransformationQuery(Resource res) {\r
 180                                 super(res);\r
 181                         }\r
 182                         \r
 183                         @Override\r
 184                         public void shapeUpdated(Graph graph, IGraphicsNode shape) {\r
 185                                 //if (shape instanceof IGeometryNode) {\r
 186                 //    updateGeometry((IGeometryNode)shape);\r
 187                 //} else {\r
 188                         shape.updateTransform(graph);\r
 189                 //}\r
 190                         }\r
 191                 }\r
 192                 \r
 193                 @Override\r
 194                 protected NodeTransformationQuery newTransformationListener(G3DNode root) {\r
 195                         return new TransformationQuery(root.getResource());\r
 196                 }\r
 197                 \r
 198                 private class NormalNodePropertyQuery extends org.simantics.proconf.g3d.base.ScenegraphAdapterImpl.NodePropertyQuery {\r
 199                         \r
 200                         public NormalNodePropertyQuery(Resource resource) {\r
 201                                 super(resource);\r
 202                         }\r
 203 \r
 204                         @Override\r
 205                         public void shapeUpdated(Graph graph,IGraphicsNode shape) {\r
 206                                 if (shape instanceof IGeometryNode) {\r
 207                     updateGeometry((IGeometryNode)shape);\r
 208                 } else {\r
 209                         shape.updateTransform(graph);\r
 210                 }\r
 211                         }\r
 212                 }\r
 213          @Override\r
 214         protected NodePropertyQuery newPropertyListener(G3DNode node) {\r
 215                 return new NormalNodePropertyQuery(node.getResource());\r
 216         }\r
 217    \r
 218          @Override\r
 219                 protected IGraphicsNode instantiateNode(IGraphicsNode parent,\r
 220                                 G3DNode node) {\r
 221                         Plant3DResource p3r = ProcessResource.plant3Dresource;\r
 222                         IGraphicsNode newNode = null;\r
 223                         try {\r
 224                                 if (node.isInstanceOf(p3r.Equipment)) {\r
 225                                         newNode = new ParameterizedModelNode(\r
 226                                                         ProcessEditor.this, parent, node.getGraph(),\r
 227                                                         node.getResource(), p3r.HasGraphics);\r
 228                                 } else if (node.isInstanceOf(p3r.PipeRun)) {\r
 229                                         newNode = new PipeRunNode(parent, node.getGraph(), node.getResource());\r
 230                                 } else if (node.isInstanceOf(p3r.Nozzle)) {\r
 231                                         newNode = new ParameterizedModelNode(\r
 232                                                         ProcessEditor.this, parent, node.getGraph(),\r
 233                                                         node.getResource(), p3r.HasGraphics);\r
 234                                         // CodedComponent must be handled first since it uses\r
 235                                         // hard-coded geometries\r
 236                                         // TODO : is this really necessary, or could we unify\r
 237                                         // PipeComponentNode, InlineComponentNode,...\r
 238                                 } else if (node.isInstanceOf(p3r.CodedComponent)) {\r
 239                                         newNode = new PipeComponentNode(ProcessEditor.this,\r
 240                                                         parent, node.getGraph(), node.getResource());\r
 241                                 } else if (node.isInstanceOf(p3r.NonVisibleComponent)) {\r
 242                                         newNode = new NonVisibleNode(parent, node.getGraph(), node.getResource());\r
 243                                 } else if (node.isInstanceOf(p3r.PipelineComponent)) {\r
 244                                         newNode = new PipelineComponentNode(ProcessEditor.this,\r
 245                                                         parent, node.getGraph(), node.getResource());\r
 246                                 } \r
 247 \r
 248                                 // } else if (node instanceof Shape) // Markers (ar/mobile)\r
 249                                 // needed this\r
 250                                 // newNode = new ShapeNode(TestProcessEditor.this,parent,node);\r
 251                                 if (newNode != null) {\r
 252                                         if (newNode instanceof ISelectableNode)\r
 253                                                 ((ISelectableNode) newNode).setVisible(true);\r
 254                                         if (newNode instanceof IGeometryNode) {\r
 255                                                 updateGeometry((IGeometryNode) newNode);\r
 256                                         }\r
 257                                         return newNode;\r
 258                                 }\r
 259                         } catch (Exception e) {\r
 260                                 ErrorLogger.defaultLogError("Cannot handle node " + node.getResource(), e);\r
 261                                 return null;\r
 262                         }\r
 263                         ErrorLogger.defaultLogError("Cannot handle node " + node.getResource(), null);\r
 264                         return null;\r
 265 \r
 266                 }\r
 267 \r
 268                 /**\r
 269                  * This is used to create elbows and straight pipes to pipeline TODO :\r
 270                  * this should be done with rule-engine!\r
 271                  * \r
 272                  * \r
 273                  * @author Marko Luukkainen\r
 274                  * \r
 275                  */\r
 276                 protected class PipeRunControlPointQuery extends NodeQuery {\r
 277                         private List<Resource> removed = new ArrayList<Resource>();\r
 278                         private List<Resource> added = new ArrayList<Resource>();\r
 279 \r
 280                         public PipeRunControlPointQuery(Resource r) {\r
 281                                 super(r);\r
 282                                 if (DEBUG) System.out.println("Created PipeRunControlPointQuery for " + r);\r
 283 \r
 284                         }\r
 285 \r
 286                         @Override\r
 287                         protected Object compute2(Graph graph) {\r
 288                                 PipeRun run = new PipeRun(graph, nodeResource);\r
 289                                 Collection<IEntity> cps = run\r
 290                                                 .getRelatedObjects(ProcessResource.plant3Dresource.HasControlPoints);\r
 291                                 List<Resource> res = new ArrayList<Resource>();\r
 292                                 for (IEntity t : cps)\r
 293                                         res.add(t.getResource());\r
 294                                 return res;\r
 295                         }\r
 296 \r
 297                         @Override\r
 298                         public boolean updated(Graph graph, Object oldResult,\r
 299                                         Object newResult) {\r
 300                                 \r
 301                                 removed.clear();\r
 302                                 added.clear();\r
 303 \r
 304                                 List<Resource> oldCps = (List<Resource>) oldResult;\r
 305                                 List<Resource> newCps = (List<Resource>) newResult;\r
 306                                 if (oldCps == null)\r
 307                                         oldCps = new ArrayList<Resource>();\r
 308 \r
 309                                 for (Resource r : oldCps) {\r
 310                                         if (!newCps.contains(r))\r
 311                                                 removed.add(r);\r
 312                                 }\r
 313 \r
 314                                 for (Resource r : newCps) {\r
 315                                         if (!oldCps.contains(r))\r
 316                                                 added.add(r);\r
 317                                 }\r
 318                                 for (Resource r : removed)\r
 319                                         removeControlPoint(graph, r);\r
 320                                 for (Resource r : added) {\r
 321                                         addControlPoint(graph, r);\r
 322                                         // ControlPointTools.addControlPoint(new\r
 323                                         // PipeRun(graph,pipeRun), new PipeControlPoint(graph, r));\r
 324                                 }\r
 325 \r
 326                                 return (added.size() > 0 || removed.size() > 0);\r
 327                         }\r
 328                         \r
 329                         @Override\r
 330                         public void dispose() {\r
 331                                 super.dispose();\r
 332                                 for (ControlPointPropertyQuery q : controlPointPropertyQueries.values())\r
 333                                         q.dispose();\r
 334                                 controlPointPropertyQueries.clear();\r
 335                         }\r
 336                         \r
 337                         private Map<Resource,ControlPointPropertyQuery> controlPointPropertyQueries = new HashMap<Resource, ControlPointPropertyQuery>();\r
 338                         \r
 339                         private void addControlPoint(Graph graph, Resource resource) {\r
 340                                 ControlPointPropertyQuery query = new ControlPointPropertyQuery(resource);\r
 341                                 graph.performQuery(query);\r
 342                                 controlPointPropertyQueries.put(resource,query);\r
 343                         }\r
 344                         \r
 345                         private void removeControlPoint(Graph graph, Resource resource) {\r
 346                                 ControlPointPropertyQuery query = controlPointPropertyQueries.remove(resource);\r
 347                                 query.dispose();\r
 348                                 ControlPointTools.removeControlPoint(new PipeControlPoint(\r
 349                                                 graph, resource));\r
 350                         }\r
 351 \r
 352                 }\r
 353 \r
 354                 protected class ControlPointPropertyQuery extends NodeQuery {\r
 355                         boolean initialized = false;\r
 356                         \r
 357                         public ControlPointPropertyQuery(Resource r) {\r
 358                                 super(r);\r
 359                                 if (DEBUG) System.out.println("Created ControlPointPropertyQuery for " + r);\r
 360                         }\r
 361                         \r
 362                         @Override\r
 363                 public List<Object> compute2(Graph g) {\r
 364                         IEntity t = EntityFactory.create(g,nodeResource);\r
 365                         \r
 366                         Collection<Property> properties = t.getRelatedProperties(ProcessResource.builtins.HasProperty);\r
 367                         List<Object> propertyValues = new ArrayList<Object>();\r
 368                         p(properties,propertyValues);\r
 369 \r
 370                         return propertyValues;\r
 371                 }\r
 372                 \r
 373                 private void p(Collection<Property> properties, List<Object> propertyValues) {\r
 374                         for (Property p : properties) {\r
 375                                 Collection<Property> subProperties = p.getRelatedProperties(p.getGraph().getBuiltins().HasProperty);\r
 376                                 if (subProperties.size() != 0) {\r
 377                                         p(subProperties,propertyValues);\r
 378                                 } \r
 379                                 if (p.hasValue()){\r
 380                                         propertyValues.add(p.getValue());\r
 381                                 }\r
 382                         }\r
 383                 }\r
 384                         \r
 385                         @Override\r
 386                         public boolean updated(Graph graph, Object oldResult, Object newResult) {\r
 387                                 PipingRules.pipeControlPointPositionUpdate(graph, this.nodeResource);\r
 388                                 if (initialized) {\r
 389                                         //PipingRules.pipeControlPointPositionUpdate(graph, this.nodeResource);\r
 390                                 } else {\r
 391                                         initialized = true;\r
 392                                 }\r
 393                                 return true;\r
 394                         }\r
 395                 }\r
 396                 \r
 397                 @Override\r
 398                 protected void removeNode(Resource parent, Resource r) {\r
 399                         super.removeNode(parent, r);\r
 400                         PipeRunControlPointQuery q = pipeRunQueries.get(r);\r
 401                         if (q != null)\r
 402                                 q.dispose();\r
 403                 }\r
 404                 \r
 405                 @Override\r
 406                 public void dispose() {\r
 407                         super.dispose();\r
 408                 }\r
 409         }\r
 410     \r
 411     @Override\r
 412     protected void pageSelectionChanged(IWorkbenchPart part, ISelection selection) {\r
 413         if (!(selection instanceof StructuredResourceSelection)) {\r
 414             return;\r
 415         }\r
 416         \r
 417         StructuredResourceSelection s = (StructuredResourceSelection) selection;\r
 418         selectionAdapter.setCurrentSelection(s);\r
 419         viewChanged = true;\r
 420         \r
 421         //if (s.getRootSelection() == null) {\r
 422         if (!(part instanceof ProcessEditor)) {\r
 423             //System.out.println("ShapeEditorView.pageSelectionChanged() no root selection");\r
 424                 ((ProcessEditorSelectionAdapter)selectionAdapter).setEditorSelection(true);\r
 425             return;\r
 426         } \r
 427         //if (!s.getRootSelection().getResource().getId().equals(plant.getResource().getId())) {\r
 428         ProcessEditor sender = (ProcessEditor)part;\r
 429         if (!sender.getPlantResource().equals(plantResource)) {\r
 430 //          System.out.println("ShapeEditorView.pageSelectionChanged() not right group "\r
 431 //                  + s.getRootSelection().getResource().getId() + " != " + model.getResource().getId());\r
 432                 selectionAdapter.setCurrentSelection(new StructuredResourceSelection());\r
 433                 ((ProcessEditorSelectionAdapter)selectionAdapter).setEditorSelection(false);\r
 434           return;\r
 435       }\r
 436         selectionAdapter.setEditorSelection();\r
 437         \r
 438     }\r
 439 \r
 440     @Override\r
 441     protected void reloadFrom(IEntity thing) {\r
 442         if (plantResource != null) {\r
 443             throw new UnsupportedOperationException("Reloading instantiated viewer not supported");\r
 444         }\r
 445         if (thing.isInstanceOf(ProcessResource.plant3Dresource.Plant)) {\r
 446             plantResource = thing.getResource();\r
 447             G3DNode plant = new G3DNode(thing);\r
 448             adapter.setRootNode(plant);\r
 449             //adapter.addOutbound(plant);\r
 450             ControlPointTools.reloadCache(thing.getGraph(),plant.getResource());\r
 451         } else {\r
 452             throw new IllegalArgumentException("Resource is not a plant");\r
 453         } \r
 454     }\r
 455 \r
 456     public Resource getPlantResource() {\r
 457         return plantResource;\r
 458     }\r
 459     \r
 460     public Plant getPlant(Graph g) {\r
 461         return new Plant(g, plantResource);\r
 462     }\r
 463     \r
 464     @Override\r
 465     protected SelectionAdapter createSelectionAdapter() {\r
 466         return new ProcessEditorSelectionAdapter(adapter);\r
 467     }\r
 468     \r
 469     protected class ProcessEditorSelectionAdapter extends SelectionAdapter {\r
 470         \r
 471         \r
 472          public ProcessEditorSelectionAdapter(ScenegraphAdapter adapter) {\r
 473                         super(adapter);\r
 474          }\r
 475 \r
 476             @Override\r
 477             public void setEditorSelection() {\r
 478                 List<IGraphicsNode> sel = getSelectedObjects();\r
 479                 for (IGraphicsNode o : adapter.getNodes())\r
 480                         if (o instanceof ISelectableNode) {\r
 481                                 if (sel.contains(o)) {\r
 482                                 ((ISelectableNode)o).setSelected(true);\r
 483                         } else {\r
 484                                 ((ISelectableNode)o).setSelected(false);\r
 485                         }\r
 486                         }\r
 487             }\r
 488             \r
 489             public void setEditorSelection(boolean addShapes) {\r
 490 \r
 491                 List<IGraphicsNode> sel = getSelectedObjects();\r
 492                 for (IGraphicsNode o : adapter.getNodes())\r
 493                         if (o instanceof ISelectableNode) {\r
 494                                 if (sel.contains(o)) {\r
 495                                 ((ISelectableNode)o).setSelected(true);\r
 496                         } else {\r
 497                                 ((ISelectableNode)o).setSelected(false);\r
 498                         }\r
 499                         }\r
 500             }\r
 501 \r
 502             @Override\r
 503             protected void setEditorHighlightSelection() {\r
 504                 List<IGraphicsNode> sel = getInteractiveSelectedObjects();\r
 505                 for (IGraphicsNode o : adapter.getNodes())\r
 506                         if (o instanceof ISelectableNode) {\r
 507                                 if (sel.contains(o)) {\r
 508                                 ((ISelectableNode)o).setHighlighted(true);\r
 509                         } else {\r
 510                                 ((ISelectableNode)o).setHighlighted(false);\r
 511                         }\r
 512                         }\r
 513             }\r
 514     }\r
 515     \r
 516     @Override\r
 517     protected void hookDragAndDrop() {\r
 518         super.hookDragAndDrop();\r
 519         dropTarget.addDropListener(new InsertEquipmentAction(this));\r
 520         dropTarget.addDropListener(new InsertNozzleAction(this));\r
 521         dropTarget.addDropListener(new InsertComponentAction(this));\r
 522         dropTarget.addDropListener(new RoutePipeAction(this));\r
 523     }\r
 524     \r
 525     @Override\r
 526         public Object getAdapter(Class adapter) {\r
 527                 if (adapter == IContentOutlinePage.class) {\r
 528                         if (getPlantResource() == null)\r
 529                                 return null;\r
 530                         final PlantStructureOutlinePage page = new PlantStructureOutlinePage(sessionContext,getPlantResource());\r
 531                         \r
 532                         getSelectionAdapter().addSelectionChangedListener(new ISelectionChangedListener() {\r
 533                                 @Override\r
 534                                 public void selectionChanged(SelectionChangedEvent event) {\r
 535                                         page.setSelection(event.getSelection());\r
 536                                         \r
 537                                 }\r
 538                         });\r
 539                         parent.getDisplay().asyncExec(new Runnable() {\r
 540                                 @Override\r
 541                                 public void run() {\r
 542                                         page.addSelectionChangedListener(new ISelectionChangedListener() {\r
 543                                                 @Override\r
 544                                                 public void selectionChanged(SelectionChangedEvent event) {\r
 545                                                         selectionAdapter.setSelection(SelectionAdapter.transformSelection(event.getSelection()));\r
 546                                                 }\r
 547                                         });\r
 548                                 }\r
 549                         });\r
 550                         \r
 551                         \r
 552                         \r
 553                         return page;\r
 554                 }\r
 555                 return null;\r
 556         }\r
 557 }