org.simantics.plant3d/src/org/simantics/plant3d/editor/P3DContentOutlinePage.java

   1 package org.simantics.plant3d.editor;
   2
   3 import org.eclipse.jface.action.IMenuListener;
   4 import org.eclipse.jface.action.IMenuManager;
   5 import org.eclipse.jface.action.MenuManager;
   6 import org.eclipse.jface.resource.JFaceResources;
   7 import org.eclipse.jface.resource.LocalResourceManager;
   8 import org.eclipse.jface.viewers.TreeViewer;
   9 import org.eclipse.swt.events.MenuDetectEvent;
  10 import org.eclipse.swt.events.MenuDetectListener;
  11 import org.eclipse.swt.graphics.Image;
  12 import org.eclipse.swt.widgets.Menu;
  13 import org.simantics.db.Resource;
  14 import org.simantics.g3d.scenegraph.base.INode;
  15 import org.simantics.g3d.scenegraph.base.ParentNode;
  16 import org.simantics.g3d.vtk.common.NodeSelectionProvider2;
  17 import org.simantics.g3d.vtk.common.VTKContentOutlinePage;
  18 import org.simantics.plant3d.Activator;
  19 import org.simantics.plant3d.scenegraph.EndComponent;
  20 import org.simantics.plant3d.scenegraph.Equipment;
  21 import org.simantics.plant3d.scenegraph.InlineComponent;
  22 import org.simantics.plant3d.scenegraph.Nozzle;
  23 import org.simantics.plant3d.scenegraph.P3DRootNode;
  24 import org.simantics.plant3d.scenegraph.PipeRun;
  25 import org.simantics.plant3d.scenegraph.PipelineComponent;
  26 import org.simantics.plant3d.scenegraph.TurnComponent;
  27 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
  28
  29 public class P3DContentOutlinePage extends VTKContentOutlinePage<Resource, Object>{
  30
  31         private static final boolean DEBUG = false;
  32         protected Menu contextMenu;
  33
  34         private LocalResourceManager manager = new LocalResourceManager(JFaceResources.getResources());
  35
  36         private Image nozzleImage;
  37         private Image pipeImage;
  38         private Image tankImage;
  39         private Image elbowImage;
  40         private Image componentImage;
  41
  42         public  P3DContentOutlinePage(ParentNode<? extends INode> rootNode, NodeSelectionProvider2<Resource,Object> provider) {
  43                 super(rootNode,provider);
  44
  45                 nozzleImage = manager.createImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Nozzle.png"));
  46                 pipeImage = manager.createImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Straight.png"));
  47                 tankImage = manager.createImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/tank.png"));
  48                 elbowImage = manager.createImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Elbow.png"));
  49                 componentImage = manager.createImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Component.png"));
  50         }
  51
  52         @Override
  53         protected void createProviders(TreeViewer viewer) {
  54                 viewer.setContentProvider(new ScenegraphContentProvider() {
  55                         @Override
  56                         public Object[] getChildren(Object parentElement) {
  57                                 if (parentElement instanceof P3DRootNode) {
  58                                         return ((P3DRootNode)parentElement).getChild().toArray();
  59                                 }
  60                                 if (!DEBUG) {
  61                                         if (parentElement instanceof PipeRun) {
  62                                                 return ((PipeRun)parentElement).getSortedChild().toArray();
  63                                         }
  64                                 } else {
  65                                         if (parentElement instanceof PipelineComponent) {
  66                                                 return new Object[]{((PipelineComponent) parentElement).getControlPoint()};
  67                                         } else if (parentElement instanceof PipeControlPoint) {
  68                                                 return new Object[]{((PipeControlPoint) parentElement).getPipelineComponent()};
  69                                         }
  70                                 }
  71                                 return super.getChildren(parentElement);
  72                         }
  73
  74                         @Override
  75                         public boolean hasChildren(Object element) {
  76                                 if (element instanceof P3DRootNode) {
  77                                         return ((P3DRootNode)element).getChild().size() > 0;
  78                                 }
  79                                 if (!DEBUG) {
  80                                         if (element instanceof PipeRun) {
  81                                                 return ((PipeRun)element).getChild().size() > 0;
  82                                         }
  83                                 } else {
  84                                         if (element instanceof PipelineComponent) {
  85                                                 return ((PipelineComponent) element).getControlPoint() != null;
  86                                         } else if (element instanceof PipeControlPoint) {
  87                                                 return ((PipeControlPoint) element).getPipelineComponent() != null;
  88                                         }
  89                                 }
  90                                 return super.hasChildren(element);
  91                         }
  92                 });
  93                 viewer.setLabelProvider(new P3DLabelProvider());
  94
  95                 hookContextMenu(viewer);
  96                 viewer.getTree().addMenuDetectListener(new MenuDetectListener() {
  97
  98                         @Override
  99                         public void menuDetected(MenuDetectEvent e) {
 100                                 contextMenu.setLocation(e.x, e.y);
 101                                 contextMenu.setVisible(true);
 102                         }
 103                 });
 104
 105         }
 106
 107         @Override
 108         public void dispose() {
 109                 manager.dispose();
 110                 super.dispose();
 111         }
 112
 113         protected void hookContextMenu(TreeViewer viewer) {
 114         MenuManager menuMgr = new MenuManager("#PopupMenu");
 115         menuMgr.setRemoveAllWhenShown(true);
 116         menuMgr.addMenuListener(new IMenuListener() {
 117             public void menuAboutToShow(IMenuManager manager) {
 118                 createContextMenu(manager);
 119             }
 120         });
 121         contextMenu = menuMgr.createContextMenu(viewer.getTree());
 122         }
 123
 124         protected void createContextMenu(IMenuManager manager) {
 125
 126         }
 127
 128         private class P3DLabelProvider extends ScenegraphLabelProvider {
 129                 @Override
 130                 public Image getImage(Object element) {
 131                         if (element instanceof PipelineComponent) {
 132                                 PipelineComponent comp = (PipelineComponent)element;
 133                                 if (comp instanceof TurnComponent) {
 134                                         return elbowImage;
 135                                 } else if (comp instanceof EndComponent) {
 136                                         return componentImage;
 137                                 } else if (comp instanceof Nozzle) {
 138                                         return nozzleImage;
 139                                 } else if (comp.getControlPoint().isFixed()) {
 140                                         return componentImage;
 141                                 }
 142                                 return pipeImage;
 143                         } else if (element instanceof Equipment) {
 144                                 return tankImage;
 145                         } else if (element instanceof PipeRun) {
 146                                 return pipeImage;
 147                         }
 148                         return null;
 149                 }
 150         }
 151 }