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