bundles/org.simantics.diagram/src/org/simantics/diagram/handler/ConnectionRoutingMenuContribution.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in 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.diagram.handler;
  13
  14 import java.util.ArrayList;
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.Comparator;
  18 import java.util.List;
  19
  20 import org.eclipse.jface.action.Action;
  21 import org.eclipse.jface.action.ContributionItem;
  22 import org.eclipse.jface.action.IAction;
  23 import org.eclipse.jface.action.IContributionItem;
  24 import org.eclipse.swt.SWT;
  25 import org.eclipse.swt.events.SelectionEvent;
  26 import org.eclipse.swt.events.SelectionListener;
  27 import org.eclipse.swt.widgets.Menu;
  28 import org.eclipse.swt.widgets.MenuItem;
  29 import org.simantics.databoard.Bindings;
  30 import org.simantics.db.ReadGraph;
  31 import org.simantics.db.Resource;
  32 import org.simantics.db.Session;
  33 import org.simantics.db.Statement;
  34 import org.simantics.db.WriteGraph;
  35 import org.simantics.db.common.CommentMetadata;
  36 import org.simantics.db.common.request.IndexRoot;
  37 import org.simantics.db.common.request.WriteRequest;
  38 import org.simantics.db.exception.DatabaseException;
  39 import org.simantics.diagram.content.ConnectionUtil;
  40 import org.simantics.diagram.stubs.DiagramResource;
  41 import org.simantics.layer0.Layer0;
  42 import org.simantics.modeling.ModelingResources;
  43 import org.simantics.scl.commands.Command;
  44 import org.simantics.scl.commands.Commands;
  45 import org.simantics.structural.stubs.StructuralResource2;
  46 import org.simantics.ui.contribution.DynamicMenuContribution;
  47 import org.simantics.utils.datastructures.Callback;
  48 import org.simantics.utils.ui.AdaptionUtils;
  49 import org.simantics.utils.ui.ExceptionUtils;
  50
  51 /**
  52  * @author Tuukka Lehtonen
  53  */
  54 public class ConnectionRoutingMenuContribution extends DynamicMenuContribution {
  55
  56
  57     private static final IContributionItem[] NONE = {};
  58
  59     @Override
  60     protected IContributionItem[] getContributionItems(ReadGraph graph, Object[] selection) throws DatabaseException {
  61         ArrayList<IContributionItem> result = new ArrayList<IContributionItem>(4);
  62
  63         result.addAll(getConnectionRoutingItems(graph, selection));
  64         result.addAll(getAttachedConnectionRoutingItems(graph, selection));
  65
  66         return result.toArray(NONE);
  67     }
  68
  69     public static Collection<IContributionItem> getConnectionRoutingItems(ReadGraph graph, Object[] selection) throws DatabaseException {
  70         Layer0 l0 = Layer0.getInstance(graph);
  71         DiagramResource dr = DiagramResource.getInstance(graph);
  72
  73         final Collection<Resource> routings = graph.getObjects(dr.Routing, l0.SuperrelationOf);
  74         if (routings.size() == 0)
  75             return Collections.emptyList();
  76
  77         final List<Resource> connections = new ArrayList<Resource>();
  78         for (Object s : selection) {
  79             Resource connection = AdaptionUtils.adaptToSingle(s, Resource.class);
  80             if (connection == null)
  81                 return Collections.emptyList();
  82             if (!graph.isInstanceOf(connection, dr.Connection))
  83                 return Collections.emptyList();
  84             // Route graph connection routing is not selected per-connection, but per-terminal.
  85             if (graph.isInstanceOf(connection, dr.RouteGraphConnection))
  86                 return Collections.emptyList();
  87             connections.add(connection);
  88         }
  89         if (connections.isEmpty())
  90             return Collections.emptyList();
  91
  92         // See if all connections have a common routing.
  93         Resource currentRoute = null;
  94         for (Resource connection : connections) {
  95             Statement currentRouting = graph.getPossibleStatement(connection, dr.Routing);
  96             if (currentRouting != null) {
  97                 Resource route = currentRouting.getPredicate();
  98                 if (currentRoute == null)
  99                     currentRoute = route;
 100                 else if (!currentRoute.equals(route)) {
 101                     currentRoute = null;
 102                     break;
 103                 }
 104             }
 105         }
 106
 107         final List<SetRoutingAction> actions = new ArrayList<SetRoutingAction>();
 108         for (Resource routing : routings) {
 109             String text = graph.adapt(routing, String.class);
 110             SetRoutingAction action = new SetRoutingAction(graph.getSession(), connections, routing, text);
 111             if (routing.equals(currentRoute))
 112                 action.setChecked(true);
 113             actions.add(action);
 114         }
 115
 116
 117         sort(actions);
 118
 119         return Collections.<IContributionItem>singleton(
 120                 new ContributionItem() {
 121                     @Override
 122                     public void fill(Menu menu, int index) {
 123                         MenuItem openWith = new MenuItem(menu, SWT.CASCADE, index);
 124                         openWith.setText("Connection Routing");
 125                         Menu subMenu = new Menu(menu);
 126                         openWith.setMenu(subMenu);
 127
 128                         for (SetRoutingAction a : actions) {
 129                             MenuItem item = new MenuItem(subMenu, SWT.CHECK);
 130                             item.setText(a.getText());
 131                             item.addSelectionListener(a);
 132                             item.setSelection(a.isChecked());
 133                         }
 134                     }
 135                 }
 136         );
 137     }
 138
 139     public static Collection<IContributionItem> getAttachedConnectionRoutingItems(ReadGraph graph, Object[] selection) throws DatabaseException {
 140         Layer0 l0 = Layer0.getInstance(graph);
 141         DiagramResource dr = DiagramResource.getInstance(graph);
 142         StructuralResource2 sr = StructuralResource2.getInstance(graph);
 143         ModelingResources MOD = ModelingResources.getInstance(graph);
 144         // HACK
 145         Resource ReferenceProvider = graph.getPossibleResource("http://www.apros.fi/Apros-6.1/ReferenceProvider");
 146         // Just continuing to do stupid things as above ;)
 147         Resource connectionType = graph.getPossibleResource("http://www.simantics.org/Kcleco-5.0/FlowConnection");
 148
 149
 150         final Collection<Resource> routings = graph.getObjects(dr.Routing, l0.SuperrelationOf);
 151         if (routings.size() == 0)
 152             return Collections.emptyList();
 153
 154         final List<Resource> connections = new ArrayList<Resource>();
 155
 156         // For route graph connections
 157         final List<Resource> connectors = new ArrayList<Resource>();
 158         boolean directRoutings = false;
 159         boolean straightRoutings = false;
 160
 161         ArrayList<Resource> elements = new ArrayList<Resource>();
 162         for (Object s : selection) {
 163             Resource element = AdaptionUtils.adaptToSingle(s, Resource.class);
 164             if (element == null)
 165                 return Collections.emptyList();
 166             if (!graph.isInstanceOf(element, dr.Element) || graph.isInstanceOf(element, dr.Connection))
 167                 return Collections.emptyList();
 168
 169             elements.add(element);
 170
 171             for(Statement stat : graph.getStatements(element, sr.IsConnectedTo)) {
 172                 Resource diagramRelation = stat.getPredicate();
 173                 Resource connectionRelation = graph.getPossibleObject(diagramRelation, MOD.DiagramConnectionRelationToConnectionRelation);
 174                 if(connectionRelation == null)
 175                     continue;
 176                 // FIXME HACK
 177                 if(ReferenceProvider != null && !graph.isInstanceOf(connectionRelation, ReferenceProvider))
 178                     continue;
 179                 Resource connector = stat.getObject();
 180
 181                 Resource connection = ConnectionUtil.tryGetConnection(graph, connector);
 182                 if (connection != null) {
 183                     if (graph.isInstanceOf(connection, dr.RouteGraphConnection)) {
 184                         if (connectionType != null && graph.isInstanceOf(connection, connectionType))
 185                             continue;
 186                         connectors.add(connector);
 187                         boolean direct = Boolean.TRUE.equals( graph.getPossibleRelatedValue2(connector, dr.Connector_straight, Bindings.BOOLEAN) );
 188                         directRoutings |= direct;
 189                         straightRoutings |= !direct;
 190                     } else {
 191                         connections.add(connection);
 192                     }
 193                 }
 194             }
 195         }
 196         if (connectors.isEmpty() && connections.isEmpty())
 197             return Collections.emptyList();
 198
 199         // See if all connections have a common routing.
 200         Resource currentRoute = null;
 201         for (Resource connection : connections) {
 202             Statement currentRouting = graph.getPossibleStatement(connection, dr.Routing);
 203             if (currentRouting != null) {
 204                 Resource route = currentRouting.getPredicate();
 205                 if (currentRoute == null)
 206                     currentRoute = route;
 207                 else if (!currentRoute.equals(route)) {
 208                     currentRoute = null;
 209                     break;
 210                 }
 211             }
 212         }
 213
 214         final List<SelectionListenerAction> actions = new ArrayList<SelectionListenerAction>();
 215
 216         if (!connections.isEmpty()) {
 217             // Handle old style connections and their routing
 218             for (Resource routing : routings) {
 219                 String text = graph.adapt(routing, String.class);
 220                 SetRoutingAction action = new SetRoutingAction(graph.getSession(), connections, routing, text);
 221                 if (routing.equals(currentRoute)) {
 222                     action.setChecked(true);
 223                 }
 224                 actions.add(action);
 225             }
 226         }
 227         if (!connectors.isEmpty()) {
 228             // Handle route graph connections
 229             SelectionListenerAction direct = new SetAttachedRouteGraphRoutingAction(graph.getSession(), elements, true, "Direct");
 230             SelectionListenerAction straight = new SetAttachedRouteGraphRoutingAction(graph.getSession(), elements, false, "Straight-angled");
 231             direct.setChecked(directRoutings);
 232             straight.setChecked(straightRoutings);
 233             actions.add(direct);
 234             actions.add(straight);
 235         }
 236
 237         sort(actions);
 238
 239         return Collections.<IContributionItem>singleton(
 240                 new ContributionItem() {
 241                     @Override
 242                     public void fill(Menu menu, int index) {
 243                         MenuItem openWith = new MenuItem(menu, SWT.CASCADE, index);
 244                         openWith.setText("Attached Connection Routing");
 245                         Menu subMenu = new Menu(menu);
 246                         openWith.setMenu(subMenu);
 247
 248                         for (SelectionListenerAction a : actions) {
 249                             MenuItem item = new MenuItem(subMenu, SWT.CHECK);
 250                             item.setText(a.getText());
 251                             item.addSelectionListener(a);
 252                             item.setSelection(a.isChecked());
 253                         }
 254                     }
 255                 }
 256         );
 257     }
 258
 259     private static void sort(List<? extends IAction> actions) {
 260         // Sort the open with actions in string order.
 261         Collections.sort(actions, new Comparator<IAction>() {
 262             @Override
 263             public int compare(IAction o1, IAction o2) {
 264                 return o1.getText().compareToIgnoreCase(o2.getText());
 265             }
 266         });
 267     }
 268
 269     static abstract class SelectionListenerAction extends Action implements SelectionListener {
 270         public SelectionListenerAction(String text) {
 271             super(text);
 272         }
 273     }
 274
 275     static class SetRoutingAction extends SelectionListenerAction {
 276
 277         Session session;
 278         Collection<Resource> connections;
 279         Resource routingTag;
 280
 281         public SetRoutingAction(Session session, Collection<Resource> connections, Resource routingTag, String text) {
 282             super(text);
 283             this.session = session;
 284             this.connections = connections;
 285             this.routingTag = routingTag;
 286         }
 287
 288         @Override
 289         public void run() {
 290             session.asyncRequest(new WriteRequest() {
 291                 @Override
 292                 public void perform(WriteGraph graph) throws DatabaseException {
 293                     DiagramResource dr = DiagramResource.getInstance(graph);
 294                     for (Resource connection : connections) {
 295                         graph.deny(connection, dr.Routing);
 296                         graph.claim(connection, routingTag, connection);
 297                     }
 298                 }
 299             }, new Callback<DatabaseException>() {
 300                 @Override
 301                 public void run(DatabaseException parameter) {
 302                     if (parameter != null)
 303                         ExceptionUtils.logError(parameter);
 304                 }
 305             });
 306         }
 307
 308         @Override
 309         public void widgetDefaultSelected(SelectionEvent e) {
 310             widgetSelected(e);
 311         }
 312
 313         @Override
 314         public void widgetSelected(SelectionEvent e) {
 315             run();
 316         }
 317
 318     }
 319
 320     static class SetAttachedRouteGraphRoutingAction extends SelectionListenerAction {
 321
 322         Session session;
 323         Collection<Resource> elements;
 324         boolean straight;
 325
 326         public SetAttachedRouteGraphRoutingAction(Session session, Collection<Resource> elements, boolean straight, String text) {
 327             super(text);
 328             this.session = session;
 329             this.elements = elements;
 330             this.straight = straight;
 331         }
 332
 333         @Override
 334         public void run() {
 335             session.asyncRequest(new WriteRequest() {
 336                 @Override
 337                 public void perform(WriteGraph graph) throws DatabaseException {
 338                     Command command = Commands.get(graph, "Simantics/Diagram/setStraightConnectionLines");
 339                     for(Resource element : elements)
 340                         command.execute(graph,
 341                                 graph.syncRequest(new IndexRoot(element)),
 342                                 element, straight);
 343
 344                     CommentMetadata cm = graph.getMetadata(CommentMetadata.class);
 345                     graph.addMetadata(cm.add("Set routing for an element."));
 346                 }
 347             }, new Callback<DatabaseException>() {
 348                 @Override
 349                 public void run(DatabaseException parameter) {
 350                     if (parameter != null)
 351                         ExceptionUtils.logError(parameter);
 352                 }
 353             });
 354         }
 355
 356         @Override
 357         public void widgetDefaultSelected(SelectionEvent e) {
 358             widgetSelected(e);
 359         }
 360
 361         @Override
 362         public void widgetSelected(SelectionEvent e) {
 363             run();
 364         }
 365
 366     }
 367
 368 }