org.simantics.g3d.csg/src/org/simantics/g3d/csg/editor/CSGEditor2.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
   3  * Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.g3d.csg.editor;
  13
  14 import java.awt.Component;
  15 import java.util.ArrayList;
  16 import java.util.Collection;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Set;
  20
  21 import org.eclipse.jface.action.IMenuListener;
  22 import org.eclipse.jface.action.IMenuManager;
  23 import org.eclipse.jface.action.MenuManager;
  24 import org.eclipse.jface.viewers.ISelectionChangedListener;
  25 import org.eclipse.jface.viewers.SelectionChangedEvent;
  26 import org.eclipse.swt.SWT;
  27 import org.eclipse.swt.events.DisposeEvent;
  28 import org.eclipse.swt.events.DisposeListener;
  29 import org.eclipse.swt.layout.FillLayout;
  30 import org.eclipse.swt.widgets.Composite;
  31 import org.eclipse.swt.widgets.Display;
  32 import org.eclipse.swt.widgets.Menu;
  33 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
  34 import org.simantics.db.ReadGraph;
  35 import org.simantics.db.Resource;
  36 import org.simantics.db.common.request.ReadRequest;
  37 import org.simantics.db.exception.DatabaseException;
  38 import org.simantics.g3d.csg.actions.AddBooleanOpAction2;
  39 import org.simantics.g3d.csg.actions.AddPrimitiveAction2;
  40 import org.simantics.g3d.csg.actions.SplitBooleanOpAction2;
  41 import org.simantics.g3d.csg.scenegraph2.BarrelNode;
  42 import org.simantics.g3d.csg.scenegraph2.BoxNode;
  43 import org.simantics.g3d.csg.scenegraph2.CSGparentNode;
  44 import org.simantics.g3d.csg.scenegraph2.CSGrootNode;
  45 import org.simantics.g3d.csg.scenegraph2.ConeNode;
  46 import org.simantics.g3d.csg.scenegraph2.CylinderNode;
  47 import org.simantics.g3d.csg.scenegraph2.DifferenceNode;
  48 import org.simantics.g3d.csg.scenegraph2.EllipticCylinderNode;
  49 import org.simantics.g3d.csg.scenegraph2.ICSGnode;
  50 import org.simantics.g3d.csg.scenegraph2.IntersectionNode;
  51 import org.simantics.g3d.csg.scenegraph2.RectangularSolidNode;
  52 import org.simantics.g3d.csg.scenegraph2.RegularPrismNode;
  53 import org.simantics.g3d.csg.scenegraph2.SchemaBuilder;
  54 import org.simantics.g3d.csg.scenegraph2.SphereNode;
  55 import org.simantics.g3d.csg.scenegraph2.TorusNode;
  56 import org.simantics.g3d.csg.scenegraph2.UnionNode;
  57 import org.simantics.g3d.scenegraph.NodeMap;
  58 import org.simantics.g3d.scenegraph.base.INode;
  59 import org.simantics.g3d.vtk.action.RemoveAction;
  60 import org.simantics.g3d.vtk.awt.InteractiveVtkPanel;
  61 import org.simantics.g3d.vtk.awt.RotateAction;
  62 import org.simantics.g3d.vtk.awt.TranslateAction;
  63 import org.simantics.g3d.vtk.awt.vtkCameraAndSelectorAction;
  64 import org.simantics.g3d.vtk.common.HoverHighlighter;
  65 import org.simantics.g3d.vtk.common.NodeSelectionProvider2;
  66 import org.simantics.g3d.vtk.common.SelectionHighlighter;
  67 import org.simantics.g3d.vtk.common.VTKContentOutlinePage;
  68 import org.simantics.g3d.vtk.common.VtkView;
  69 import org.simantics.g3d.vtk.shape.vtkShape;
  70 import org.simantics.g3d.vtk.utils.vtkPanelUtil;
  71 import org.simantics.objmap.graph.IMapping;
  72 import org.simantics.objmap.graph.Mappings;
  73 import org.simantics.objmap.graph.schema.IMappingSchema;
  74 import org.simantics.selectionview.StandardPropertyPage;
  75 import org.simantics.ui.workbench.IPropertyPage;
  76 import org.simantics.ui.workbench.IResourceEditorInput;
  77 import org.simantics.ui.workbench.ResourceEditorPart;
  78 import org.simantics.utils.threads.AWTThread;
  79 import org.simantics.utils.threads.ThreadUtils;
  80 import org.simantics.utils.ui.ExceptionUtils;
  81 import org.simantics.utils.ui.SWTAWTComponent;
  82
  83 import vtk.vtkActor;
  84 import vtk.vtkCameraPass;
  85 import vtk.vtkDefaultPass;
  86 import vtk.vtkLightsPass;
  87 import vtk.vtkRenderPassCollection;
  88 import vtk.vtkRenderer;
  89 import vtk.vtkSequencePass;
  90
  91 public class CSGEditor2  extends ResourceEditorPart {
  92         private Composite parent;
  93         private Resource input;
  94         private InteractiveVtkPanel panel;
  95         private SWTAWTComponent component;
  96
  97         private CSGrootNode rootNode;
  98         private IMapping<Resource, INode> mapping;
  99
 100         private NodeSelectionProvider2<Resource, INode> selectionProvider;
 101
 102         private vtkCameraAndSelectorAction cameraAction;
 103         private TranslateAction translateAction;
 104         private RotateAction rotateAction;
 105         private RemoveAction removeAction;
 106
 107         //private  ScenegraphOutlinePage outlinePage;
 108
 109         private CSGNodeMap nodeMap;
 110
 111
 112
 113         @Override
 114         public void createPartControl(Composite parent) {
 115                 this.parent = parent;
 116                 parent.setLayout (new FillLayout ());
 117                 component = new SWTAWTComponent(parent,SWT.NONE) {
 118
 119                         @Override
 120                         protected Component createSwingComponent() {
 121                                 if (panel == null) {
 122                                         panel = new InteractiveVtkPanel();
 123                                         vtkPanelUtil.registerPanel(panel);
 124                                         createScene();
 125                                 }
 126                                 return panel;
 127                         }
 128                 };
 129
 130                 IResourceEditorInput rei = (IResourceEditorInput)getEditorInput();
 131                 input = rei.getResource();
 132
 133
 134                 //IActionBars actionBars = getEditorSite().getActionBars();
 135
 136                 hookContextMenu();
 137
 138                 component.syncPopulate();
 139
 140                 panel.addMouseListener(new java.awt.event.MouseAdapter() {
 141                         @Override
 142                         public void mouseClicked(final java.awt.event.MouseEvent e) {
 143                                 if (e.getButton() == java.awt.event.MouseEvent.BUTTON3) {
 144                                         Display.getDefault().asyncExec(new Runnable() {
 145                                                 public void run() {
 146                                                         contextMenu.setLocation(e.getXOnScreen(), e.getYOnScreen());
 147                                                         contextMenu.setVisible(true);
 148                                                 }
 149                                         });
 150                                 }
 151                         }
 152                 });
 153
 154
 155                 cameraAction = new vtkCameraAndSelectorAction(panel);
 156                 panel.setDefaultAction(cameraAction);
 157                 panel.useDefaultAction();
 158
 159                 try {
 160                         getSession().syncRequest(new ReadRequest() {
 161
 162                                 @SuppressWarnings({ "rawtypes", "unchecked" })
 163                                 @Override
 164                                 public void run(ReadGraph graph) throws DatabaseException {
 165                                         IMappingSchema schema = SchemaBuilder.getSchema(graph);
 166                                         mapping = Mappings.createWithListening(schema);
 167                                         rootNode = (CSGrootNode)mapping.map(graph, input);
 168                                         nodeMap = new CSGNodeMap(getSession(), mapping, panel,(CSGrootNode)rootNode);
 169                                 }
 170                         });
 171
 172                         if (rootNode == null)
 173                                 throw new RuntimeException("Scenegraph loading failed.");
 174                         populate();
 175
 176                         selectionProvider = new NodeSelectionProvider2<Resource,INode>(this,mapping,nodeMap);
 177
 178                         cameraAction.addSelectionChangedListener(selectionProvider);
 179
 180                         cameraAction.addHoverChangedListener(new HoverHighlighter<Resource>(panel,nodeMap));
 181                         selectionProvider.addSelectionChangedListener(new SelectionHighlighter<Resource>(panel,nodeMap));
 182
 183                         getSite().setSelectionProvider(selectionProvider);
 184                         getSite().getPage().addPostSelectionListener(selectionProvider);
 185
 186                         //outlinePage = new ScenegraphOutlinePage(rootNode);
 187
 188
 189                         parent.addDisposeListener(new DisposeListener() {
 190
 191                                 @Override
 192                                 public void widgetDisposed(DisposeEvent e) {
 193                                         getSite().getPage().removePostSelectionListener(selectionProvider);
 194                                         ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {
 195
 196                                                 @Override
 197                                                 public void run() {
 198                                                         nodeMap.delete();
 199                                                         vtkPanelUtil.unregisterPanel(panel);
 200
 201                                                 }
 202                                         });
 203                                         mapping.dispose();
 204                                         component.dispose();
 205
 206
 207                                 }
 208                         });
 209                 } catch (DatabaseException e1) {
 210                         ExceptionUtils.logAndShowError("Cannot open CSG editor",e1);
 211                         return;
 212                 }
 213
 214                 translateAction = new TranslateAction(panel,nodeMap);
 215                 rotateAction = new RotateAction(panel,nodeMap);
 216                 removeAction = new RemoveAction(nodeMap) {
 217                         @Override
 218                         public void setNode(INode node) {
 219                                 super.setNode(node);
 220                                 if (node.getParent() instanceof CSGparentNode)
 221                                         setEnabled(false);
 222                         }
 223                 };
 224
 225
 226         }
 227
 228
 229
 230
 231         public void populate() {
 232                 ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {
 233
 234                         @Override
 235                         public void run() {
 236                                 nodeMap.populate();
 237                         }
 238                 });
 239
 240         }
 241
 242
 243
 244         @Override
 245         public void setFocus() {
 246                 component.setFocus();
 247         }
 248
 249         private void createScene() {
 250                 vtkRenderer ren1 = panel.GetRenderer();
 251
 252                 boolean multiPass = false;
 253                 if (multiPass) {
 254
 255                         vtkLightsPass lightsPass = new vtkLightsPass();
 256                         vtkDefaultPass defaultPass = new vtkDefaultPass();
 257
 258
 259                         vtkRenderPassCollection passes = new vtkRenderPassCollection();
 260                         passes.AddItem(lightsPass);
 261                         passes.AddItem(defaultPass);
 262
 263                         vtkSequencePass seq = new vtkSequencePass();
 264                         seq.SetPasses(passes);
 265
 266
 267
 268                         vtkCameraPass cameraPass = new vtkCameraPass();
 269                         cameraPass.SetDelegatePass(seq);
 270
 271                         ren1.SetPass(cameraPass);
 272
 273                 }
 274 //              ren1.GetRenderWindow().LineSmoothingOn();
 275 //              ren1.GetRenderWindow().PointSmoothingOn();
 276 //              ren1.GetRenderWindow().PolygonSmoothingOn();
 277 //              ren1.GetRenderWindow().SetMultiSamples(2);
 278
 279
 280
 281                 ren1.SetBackground2(1,1,1); // background color white
 282                 ren1.SetBackground(0.9,0.9,0.9);
 283                 ren1.SetGradientBackground(true);
 284
 285                 // vtkActor grid = vtkShape.createGridActor(8,1.0,1|2|4);
 286                 vtkActor grid = vtkShape.createGridActor(8,1.0, 2 );
 287                 grid.SetPickable(0);
 288                 ren1.AddActor(grid);
 289                 panel.addDeletable(grid);
 290
 291
 292
 293         }
 294
 295         protected Menu contextMenu;
 296
 297         protected void hookContextMenu() {
 298                 MenuManager menuMgr = new MenuManager("#PopupMenu");
 299                 menuMgr.setRemoveAllWhenShown(true);
 300                 menuMgr.addMenuListener(new IMenuListener() {
 301                         public void menuAboutToShow(IMenuManager manager) {
 302                                 final IMenuManager m = manager;
 303                                 List<INode> selected = selectionProvider.getSelectedNodes();
 304                                 if (selected.size() == 0) {
 305                                         m.add(new AddPrimitiveAction2(rootNode, BarrelNode.class));
 306                                         m.add(new AddPrimitiveAction2(rootNode, BoxNode.class));
 307                                         m.add(new AddPrimitiveAction2(rootNode, ConeNode.class));
 308                                         m.add(new AddPrimitiveAction2(rootNode, CylinderNode.class));
 309                                         m.add(new AddPrimitiveAction2(rootNode, EllipticCylinderNode.class));
 310                                         m.add(new AddPrimitiveAction2(rootNode, RectangularSolidNode.class));
 311                                         m.add(new AddPrimitiveAction2(rootNode, RegularPrismNode.class));
 312                                         m.add(new AddPrimitiveAction2(rootNode, SphereNode.class));
 313                                         m.add(new AddPrimitiveAction2(rootNode, TorusNode.class));
 314                                 } else if (selected.size() == 1) {
 315                                         m.add(translateAction);
 316                                         m.add(rotateAction);
 317                                         m.add(removeAction);
 318                                         ICSGnode node = (ICSGnode)selected.get(0);
 319                                         translateAction.setNode(node);
 320                                         rotateAction.setNode(node);
 321                                         removeAction.setNode(node);
 322                                         if (node instanceof CSGparentNode) {
 323                                                 m.add(new SplitBooleanOpAction2(rootNode,(CSGparentNode)node));
 324                                         }
 325                                 } else if (selected.size() == 2) {
 326                                         if (selected.get(0).getParent().equals(rootNode) && selected.get(1).getParent().equals(rootNode)) {
 327                                                 Collection<ICSGnode> nodes = new ArrayList<ICSGnode>();
 328                                                 for (INode n : selected)
 329                                                         nodes.add((ICSGnode)n);
 330                                                 m.add(new AddBooleanOpAction2(rootNode, DifferenceNode.class, nodes));
 331                                                 m.add(new AddBooleanOpAction2(rootNode, IntersectionNode.class, nodes));
 332                                                 m.add(new AddBooleanOpAction2(rootNode, UnionNode.class, nodes));
 333                                         }
 334                                 }
 335 //              try {
 336 //                                      SimanticsUI.getSession().syncRequest(new ReadRequest() {
 337 //
 338 //                                              @Override
 339 //                                              public void run(ReadGraph graph) throws DatabaseException {
 340 //                                                      Layer0 l0 = Layer0.getInstance(graph);
 341 //                                                      CSG csg = CSG.getInstance(graph);
 342 //                                                      Resource ontology = graph.getResource("http://www.simantics.org/CSG-0.1");
 343 //
 344 //                                                      if (selectionProvider.getSelectedResources().size() == 0) {
 345 //                                                              List<NamedResource> primitives = new ArrayList<NamedResource>();
 346 //                                                              for (Resource r : graph.getObjects(ontology, l0.ConsistsOf)) {
 347 //                                                                      if (graph.isInheritedFrom(r, csg.Primitive) && !r.equals(csg.Primitive)) {
 348 //                                                                              primitives.add(new NamedResource((String)graph.getRelatedValue(r, l0.HasName), r));
 349 //                                                                      }
 350 //                                                              }
 351 //
 352 //                                                              Collections.sort(primitives);
 353 //                                                              for (NamedResource n : primitives) {
 354 //                                                                      m.add(new AddPrimitiveAction(graph, n.getResource(),input));
 355 //                                                              }
 356 //                                                      }
 357 //                                                      if (selectionProvider.getSelectedResources().size() == 2) {
 358 //                                                              List<NamedResource> booleanOps = new ArrayList<NamedResource>();
 359 //                                                              for (Resource r : graph.getObjects(ontology, l0.ConsistsOf)) {
 360 //                                                                      if (graph.isInheritedFrom(r, csg.BooleanOperation) && !r.equals(csg.BooleanOperation)) {
 361 //                                                                              booleanOps.add(new NamedResource((String)graph.getRelatedValue(r, l0.HasName), r));
 362 //                                                                      }
 363 //                                                              }
 364 //
 365 //                                                              Collections.sort(booleanOps);
 366 //                                                              for (NamedResource n : booleanOps) {
 367 //                                                                      m.add(new AddBooleanOpAction(graph, n.getResource(), input, selectionProvider.getSelectedResources()));
 368 //                                                              }
 369 //                                                      }
 370 //                                                      if (selectionProvider.getSelectedResources().size() == 1) {
 371 //                                                              m.add(translateAction);
 372 //                                                              m.add(rotateAction);
 373 //                                                              m.add(removeAction);
 374 //                                                              Resource selected = selectionProvider.getSelectedResources().get(0);
 375 //                                                              translateAction.setNode((IG3DNode2)mapping.get(selected));
 376 //                                                              rotateAction.setNode((IG3DNode2)mapping.get(selected));
 377 //                                                              removeAction.setNode((IG3DNode2)mapping.get(selected));
 378 //                                                              if (graph.isInstanceOf(selected, csg.BooleanOperation)) {
 379 //                                                                      m.add(new SplitBooleanOpAction(input,selected));
 380 //                                                              }
 381 //
 382 //
 383 //                                                      }
 384 //
 385 //                                              }
 386 //                                      });
 387 //                              } catch (DatabaseException e) {
 388 //                                      // TODO Auto-generated catch block
 389 //                                      e.printStackTrace();
 390 //                              }
 391
 392                         }
 393                 });
 394
 395                 contextMenu = menuMgr.createContextMenu(parent);
 396         }
 397
 398         private IContentOutlinePage createOutline() {
 399                 if (rootNode == null || selectionProvider == null)
 400                         return null;
 401                 IContentOutlinePage outlinePage = new VTKContentOutlinePage<Resource,INode>(rootNode, selectionProvider);
 402                 outlinePage.addSelectionChangedListener(new ISelectionChangedListener() {
 403
 404                         @Override
 405                         public void selectionChanged(SelectionChangedEvent event) {
 406                                 selectionProvider.selectionChanged(event);
 407                         }
 408                 });
 409                 return outlinePage;
 410         }
 411
 412         @Override
 413         public <T> T getAdapter(Class<T> adapter) {
 414                 if (adapter.isAssignableFrom(IPropertyPage.class))
 415                         return adapter.cast(new StandardPropertyPage(getSite(),getPropertyContexts()));
 416                 if (adapter.isAssignableFrom(IContentOutlinePage.class)) {
 417                         return adapter.cast(createOutline());
 418                 }
 419                 if (adapter.isAssignableFrom(NodeMap.class)) {
 420                         return adapter.cast(nodeMap);
 421                 }
 422                 if (adapter.isAssignableFrom(INode.class)) {
 423                         return adapter.cast(rootNode);
 424                 }
 425                 if (adapter.isAssignableFrom(IMapping.class)) {
 426                         return adapter.cast(mapping);
 427                 }
 428                 if (adapter.isAssignableFrom(InteractiveVtkPanel.class)) {
 429                         return adapter.cast(panel);
 430                 }
 431                 if (adapter.isAssignableFrom(VtkView.class))
 432                         return adapter.cast(panel);
 433                 return super.getAdapter(adapter);
 434         }
 435
 436         public Set<String> getPropertyContexts() {
 437                 Set<String> result = new HashSet<String>();
 438                 result.add("http://www.simantics.org/Project-1.0/ProjectBrowseContext");
 439                 return result;
 440         }
 441 }