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

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