1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.diagram.synchronization.graph;
\r
14 import gnu.trove.set.hash.THashSet;
\r
16 import java.awt.geom.AffineTransform;
\r
17 import java.lang.reflect.Array;
\r
18 import java.util.ArrayList;
\r
19 import java.util.Arrays;
\r
20 import java.util.Collection;
\r
21 import java.util.Collections;
\r
22 import java.util.List;
\r
23 import java.util.Set;
\r
25 import org.simantics.Simantics;
\r
26 import org.simantics.databoard.Bindings;
\r
27 import org.simantics.databoard.binding.Binding;
\r
28 import org.simantics.datatypes.literal.Vec2d;
\r
29 import org.simantics.db.AsyncReadGraph;
\r
30 import org.simantics.db.ReadGraph;
\r
31 import org.simantics.db.Resource;
\r
32 import org.simantics.db.Statement;
\r
33 import org.simantics.db.WriteGraph;
\r
34 import org.simantics.db.common.CommentMetadata;
\r
35 import org.simantics.db.common.primitiverequest.OrderedSet;
\r
36 import org.simantics.db.common.request.IndexRoot;
\r
37 import org.simantics.db.common.request.Queries;
\r
38 import org.simantics.db.common.utils.NameUtils;
\r
39 import org.simantics.db.common.utils.OrderedSetUtils;
\r
40 import org.simantics.db.exception.DatabaseException;
\r
41 import org.simantics.db.exception.DoesNotContainValueException;
\r
42 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
\r
43 import org.simantics.db.exception.NoSingleResultException;
\r
44 import org.simantics.db.exception.ServiceException;
\r
45 import org.simantics.db.exception.ValidationException;
\r
46 import org.simantics.db.layer0.request.PossibleModel;
\r
47 import org.simantics.db.procedure.AsyncProcedure;
\r
48 import org.simantics.diagram.connection.ConnectionSegmentEnd;
\r
49 import org.simantics.diagram.connection.ConnectionVisuals;
\r
50 import org.simantics.diagram.content.ConnectionUtil;
\r
51 import org.simantics.diagram.content.DesignatedTerminal;
\r
52 import org.simantics.diagram.content.ElementContext;
\r
53 import org.simantics.diagram.content.ResourceTerminal;
\r
54 import org.simantics.diagram.content.TerminalMap;
\r
55 import org.simantics.diagram.internal.DebugPolicy;
\r
56 import org.simantics.diagram.query.DiagramRequests;
\r
57 import org.simantics.diagram.stubs.DiagramResource;
\r
58 import org.simantics.diagram.stubs.G2DResource;
\r
59 import org.simantics.g2d.connection.EdgeVisualsConfigurer;
\r
60 import org.simantics.g2d.diagram.IDiagram;
\r
61 import org.simantics.g2d.diagram.handler.DataElementMap;
\r
62 import org.simantics.g2d.diagram.handler.Topology.Terminal;
\r
63 import org.simantics.g2d.element.ElementHints;
\r
64 import org.simantics.g2d.element.IElement;
\r
65 import org.simantics.g2d.element.handler.EdgeVisuals;
\r
66 import org.simantics.g2d.element.handler.EdgeVisuals.ArrowType;
\r
67 import org.simantics.g2d.element.handler.EdgeVisuals.EdgeEnd;
\r
68 import org.simantics.g2d.element.handler.FillColor;
\r
69 import org.simantics.g2d.element.handler.TerminalTopology;
\r
70 import org.simantics.g2d.elementclass.FlagClass;
\r
71 import org.simantics.g2d.elementclass.FlagClass.Type;
\r
72 import org.simantics.g2d.page.DiagramDesc;
\r
73 import org.simantics.g2d.routing.IRouter2;
\r
74 import org.simantics.g2d.svg.LineCap;
\r
75 import org.simantics.g2d.svg.LineJoin;
\r
76 import org.simantics.g2d.utils.Alignment;
\r
77 import org.simantics.layer0.Layer0;
\r
78 import org.simantics.layer0.utils.binaryPredicates.OrderedSetElementsPredicate;
\r
79 import org.simantics.modeling.ModelingResources;
\r
80 import org.simantics.scl.commands.Commands;
\r
81 import org.simantics.structural.stubs.StructuralResource2;
\r
82 import org.simantics.structural2.modelingRules.CPTerminal;
\r
83 import org.simantics.structural2.modelingRules.IAttachmentRelationMap;
\r
84 import org.simantics.structural2.modelingRules.IConnectionPoint;
\r
85 import org.simantics.structural2.modelingRules.IModelingRules;
\r
86 import org.simantics.ui.selection.WorkbenchSelectionElement;
\r
87 import org.simantics.utils.page.MarginUtils.Margin;
\r
88 import org.simantics.utils.page.MarginUtils.Margins;
\r
89 import org.simantics.utils.page.PageCentering;
\r
90 import org.simantics.utils.page.PageDesc;
\r
91 import org.simantics.utils.page.PageOrientation;
\r
92 import org.simantics.utils.ui.ErrorLogger;
\r
95 * @author Tuukka Lehtonen
\r
97 public final class DiagramGraphUtil {
\r
99 public static double[] validateAffineTransform(Resource resource, double[] matrix) {
\r
100 if (matrix != null) {
\r
101 if (matrix.length < 4) {
\r
102 ErrorLogger.defaultLogError("resource " + resource + " matrix too small for AffineTransform: " + Arrays.toString(matrix), new Exception("trace"));
\r
106 // Validate scale/rotation part
\r
107 if (DebugPolicy.DEBUG_TRANSFORM_LOAD) {
\r
108 double det = new AffineTransform(matrix).getDeterminant();
\r
109 double detabs = Math.abs(det);
\r
110 if (detabs < DebugPolicy.DETERMINANT_LIMIT_LOW)
\r
111 ErrorLogger.defaultLogWarning("resource " + resource + " transform determinant absolute value is close to zero: " + detabs + "(transform=" + Arrays.toString(matrix) + ")", new Exception("trace"));
\r
112 if (detabs > DebugPolicy.DETERMINANT_LIMIT_HIGH)
\r
113 ErrorLogger.defaultLogWarning("resource " + resource + " transform determinant absolute value is suspiciously large: " + detabs + "(transform=" + Arrays.toString(matrix) + ")", new Exception("trace"));
\r
116 if (matrix.length > 5) {
\r
117 // Validate translation
\r
118 double xabs = Math.abs(matrix[4]);
\r
119 double yabs = Math.abs(matrix[5]);
\r
120 double limit = DebugPolicy.TRANSLATION_LIMIT_HIGH;
\r
121 boolean largeX = xabs > limit;
\r
122 boolean largeY = yabs > limit;
\r
123 if (largeX || largeY)
\r
124 ErrorLogger.defaultLogWarning("resource " + resource + " transform translation is suspiciously large: " + Arrays.toString(matrix), new Exception("trace"));
\r
131 public static AffineTransform getAffineTransform(ReadGraph graph, Resource resource) throws DatabaseException {
\r
132 G2DResource g2d = G2DResource.getInstance(graph);
\r
133 return getAffineTransform(graph, resource, g2d.HasTransform, true);
\r
136 public static Vec2d getOffset(ReadGraph graph, Resource resource) throws DatabaseException {
\r
137 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
138 Vec2d offset = graph.getPossibleRelatedValue(resource, DIA.Element_profileMonitorOffset, Vec2d.BINDING);
\r
139 if(offset != null) return offset;
\r
140 else return new Vec2d(0, 0);
\r
143 public static boolean getProfileMonitorsHidden(ReadGraph graph, Resource resource) throws DatabaseException {
\r
144 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
145 Boolean value = graph.getPossibleRelatedValue(resource, DIA.Element_hideProfileMonitors, Bindings.BOOLEAN);
\r
146 if(value == null) value = false;
\r
150 public static boolean getProfileMonitorsUp(ReadGraph graph, Resource resource) throws DatabaseException {
\r
151 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
152 Boolean value = graph.getPossibleRelatedValue(resource, DIA.Element_upProfileMonitors, Bindings.BOOLEAN);
\r
153 if(value == null) value = true;
\r
157 public static double getProfileMonitorSpacing(ReadGraph graph, Resource resource) throws DatabaseException {
\r
158 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
159 Double value = graph.getPossibleRelatedValue(resource, DIA.Element_profileMonitorSpacing, Bindings.DOUBLE);
\r
160 if(value == null) value = 0.0;
\r
164 public static AffineTransform getDynamicAffineTransform(ReadGraph graph, Resource runtime, Resource element) throws DatabaseException {
\r
165 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
166 return getDynamicAffineTransform(graph, runtime, element, DIA.HasDynamicTransform, true);
\r
173 * @throws DatabaseException
\r
175 public static AffineTransform getWorldTransform(ReadGraph graph, Resource element) throws DatabaseException {
\r
176 ModelingResources MOD = ModelingResources.getInstance(graph);
\r
177 AffineTransform result = DiagramGraphUtil.getAffineTransform(graph, element);
\r
179 Resource parentComponent = graph.getPossibleObject(element, MOD.HasParentComponent);
\r
180 if (parentComponent == null)
\r
182 element = graph.getPossibleObject(parentComponent, MOD.ComponentToElement);
\r
183 if (element == null)
\r
185 AffineTransform tr = DiagramGraphUtil.getAffineTransform(graph, element);
\r
186 tr.setToTranslation(tr.getTranslateX(), tr.getTranslateY());
\r
187 result.preConcatenate(tr);
\r
196 * @throws DatabaseException
\r
198 public static AffineTransform getDynamicWorldTransform(ReadGraph graph, Resource runtime, Resource element) throws DatabaseException {
\r
199 ModelingResources MOD = ModelingResources.getInstance(graph);
\r
200 AffineTransform result = DiagramGraphUtil.getDynamicAffineTransform(graph, runtime, element);
\r
202 Resource parentComponent = graph.getPossibleObject(element, MOD.HasParentComponent);
\r
203 if (parentComponent == null)
\r
205 element = graph.getPossibleObject(parentComponent, MOD.ComponentToElement);
\r
206 if (element == null)
\r
208 AffineTransform tr = DiagramGraphUtil.getDynamicAffineTransform(graph, runtime, element);
\r
209 tr.setToTranslation(tr.getTranslateX(), tr.getTranslateY());
\r
210 result.preConcatenate(tr);
\r
218 * @param invalidAsIdentity true to return invalid transforms as identity
\r
219 * transforms, <code>false</code> to return <code>null</code>
\r
221 * @throws DatabaseException
\r
223 public static AffineTransform getAffineTransform(ReadGraph graph, Resource resource, Resource relation, boolean invalidAsIdentity) throws DatabaseException {
\r
224 double mat[] = getPossibleRelatedDoubleArray(graph, resource, relation);
\r
225 mat = validateAffineTransform(resource, mat);
\r
226 return mat != null ? new AffineTransform(mat) :
\r
227 invalidAsIdentity ? new AffineTransform() : null;
\r
230 public static AffineTransform getDynamicAffineTransform(ReadGraph graph, Resource runtime, Resource element, Resource relation, boolean invalidAsIdentity) throws DatabaseException {
\r
231 double mat[] = graph.getPossibleRelatedValue2(element, relation, new ElementContext(runtime, element), Bindings.DOUBLE_ARRAY);
\r
232 mat = validateAffineTransform(element, mat);
\r
233 return mat != null ? new AffineTransform(mat) :
\r
234 invalidAsIdentity ? new AffineTransform() : null;
\r
237 public static double[] getPossibleRelatedDoubleArray(ReadGraph graph, Resource resource, Resource relation) throws DatabaseException {
\r
238 Resource res = graph.getPossibleObject(resource, relation);
\r
241 return graph.getValue(res, Bindings.getBindingUnchecked(double[].class));
\r
244 public static AffineTransform getTransform(ReadGraph graph, Resource resource) throws DatabaseException {
\r
245 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
247 double[] matrix = graph.getPossibleRelatedValue(resource, DIA.HasTransform, Bindings.DOUBLE_ARRAY);
\r
248 if (matrix == null)
\r
249 return new AffineTransform();
\r
250 if (matrix.length < 4)
\r
251 return new AffineTransform();
\r
252 return new AffineTransform(matrix);
\r
255 public static void setTransform(WriteGraph graph, Resource resource, AffineTransform at) throws DatabaseException {
\r
256 double[] matrix = new double[6];
\r
257 at.getMatrix(matrix);
\r
258 changeTransform(graph, resource, matrix);
\r
261 public static void setTransform(WriteGraph graph, Resource resource, double[] matrix) throws DatabaseException {
\r
262 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
263 G2DResource G2D = G2DResource.getInstance(graph);
\r
265 setRelatedValue(graph, resource, DIA.HasTransform, G2D.Transform, matrix, Bindings.DOUBLE_ARRAY);
\r
268 public static void changeTransform(WriteGraph graph, Resource resource, AffineTransform at) throws DatabaseException {
\r
269 double[] matrix = new double[6];
\r
270 at.getMatrix(matrix);
\r
271 changeTransform(graph, resource, matrix);
\r
274 public static void changeTransform(WriteGraph graph, Resource resource, double[] matrix) throws DatabaseException {
\r
275 Commands.get(graph, "Simantics/Diagram/setTransform")
\r
276 .execute(graph, graph.syncRequest(new IndexRoot(resource)), resource, matrix);
\r
279 public static void setRelatedValue(WriteGraph graph, Resource resource, Resource relation, Resource valueType, Object arrayValue, Binding binding) throws DatabaseException {
\r
280 Statement stm = graph.getPossibleStatement(resource, relation);
\r
282 addRelatedValue(graph, resource, relation, valueType, arrayValue, binding);
\r
284 // statement might be asserted, check this before overwriting
\r
285 if (!stm.getSubject().equals(resource)) {
\r
286 // Asserted, just add a new related value
\r
287 addRelatedValue(graph, resource, relation, valueType, arrayValue, binding);
\r
289 //Object old = graph.getValue2(p);
\r
290 //if (!Arrays.equals(old, arrayValue))
\r
291 graph.claimValue(stm.getObject(), arrayValue, binding);
\r
296 public static Resource addRelatedValue(WriteGraph graph, Resource resource, Resource relation, Resource valueType, Object arrayValue, Binding binding) throws DatabaseException {
\r
297 Resource d = graph.newResource();
\r
298 Layer0 b = Layer0.getInstance(graph);
\r
299 graph.claim(d, b.InstanceOf, null, valueType);
\r
300 graph.claimValue(d, arrayValue);
\r
301 graph.claim(resource, relation, d);
\r
305 public static <T> T getPossibleRelatedValue(ReadGraph graph, Resource r, Resource relation, Class<T> valueClass, T defaultValue) throws DatabaseException {
\r
306 Resource object = graph.getPossibleObject(r, relation);
\r
307 if (object == null)
\r
308 return defaultValue;
\r
309 T t = graph.getPossibleValue(object, Bindings.getBindingUnchecked(valueClass));
\r
310 if (t != null && valueClass.isArray()) {
\r
311 if (defaultValue != null) {
\r
312 int defaultValueLength = Array.getLength(defaultValue);
\r
313 int valueLength = Array.getLength(t);
\r
314 if (valueLength < defaultValueLength)
\r
315 return defaultValue;
\r
318 return t == null ? defaultValue : t;
\r
321 public static Resource getConnectionPointOfTerminal(ReadGraph g, Terminal forTerminal) throws DatabaseException {
\r
322 if (forTerminal instanceof ResourceTerminal)
\r
323 return getConnectionPointOfTerminal(g, ((ResourceTerminal) forTerminal).getResource());
\r
327 public static Resource tryGetBindingRelation(ReadGraph g, Terminal forTerminal) throws DatabaseException {
\r
328 if (forTerminal instanceof ResourceTerminal)
\r
329 return getPossibleConnectionPointOfTerminal(g, ((ResourceTerminal) forTerminal).getResource());
\r
333 public static LineJoin toLineJoin(G2DResource g2d, Resource lineJoin) {
\r
334 if (lineJoin != null) {
\r
335 if (lineJoin.equals(g2d.LineJoin_BevelJoin))
\r
336 return LineJoin.bevel;
\r
337 if (lineJoin.equals(g2d.LineJoin_RoundJoin))
\r
338 return LineJoin.round;
\r
340 return LineJoin.miter;
\r
343 public static LineCap toLineCap(G2DResource g2d, Resource lineCap) {
\r
344 if (lineCap != null) {
\r
345 if (lineCap.equals(g2d.LineCap_ButtCap))
\r
346 return LineCap.butt;
\r
347 if (lineCap.equals(g2d.LineCap_RoundCap))
\r
348 return LineCap.round;
\r
350 return LineCap.square;
\r
353 public static Resource toLineJoin(G2DResource g2d, LineJoin lineJoin) {
\r
354 if (lineJoin != null) {
\r
355 if (lineJoin.equals(LineJoin.bevel))
\r
356 return g2d.LineJoin_BevelJoin;
\r
357 if (lineJoin.equals(LineJoin.round))
\r
358 return g2d.LineJoin_RoundJoin;
\r
360 return g2d.LineJoin_MiterJoin;
\r
363 public static Resource toLineCap(G2DResource g2d, LineCap lineCap) {
\r
364 if (lineCap != null) {
\r
365 if (lineCap.equals(LineCap.butt))
\r
366 return g2d.LineCap_ButtCap;
\r
367 if (lineCap.equals(LineCap.round))
\r
368 return g2d.LineCap_RoundCap;
\r
370 return g2d.LineCap_SquareCap;
\r
373 public static Alignment toAlignment(Resource align, G2DResource g2d, Alignment defaultValue) {
\r
375 return defaultValue;
\r
376 if (align.equals(g2d.Alignment_Leading))
\r
377 return Alignment.LEADING;
\r
378 if (align.equals(g2d.Alignment_Trailing))
\r
379 return Alignment.TRAILING;
\r
380 if (align.equals(g2d.Alignment_Center))
\r
381 return Alignment.CENTER;
\r
382 return defaultValue;
\r
385 public static Alignment toVerticalAlignment(Resource align, G2DResource g2d, Alignment defaultValue) {
\r
387 return defaultValue;
\r
388 if (align.equals(g2d.Alignment_Leading))
\r
389 return Alignment.LEADING;
\r
390 if (align.equals(g2d.Alignment_Trailing))
\r
391 return Alignment.TRAILING;
\r
392 if (align.equals(g2d.Alignment_Center))
\r
393 return Alignment.CENTER;
\r
394 if (align.equals(g2d.Alignment_Baseline))
\r
395 return Alignment.BASELINE;
\r
396 return defaultValue;
\r
400 public static Resource toFlagTypeResource(DiagramResource dr, FlagClass.Type type) {
\r
402 case In: return dr.FlagType_InputFlag;
\r
403 case Out: return dr.FlagType_OutputFlag;
\r
404 default: throw new IllegalArgumentException("unsupported flag type: " + type);
\r
408 public static FlagClass.Type toFlagType(DiagramResource dr, Resource type) {
\r
409 return toFlagType(dr, type, Type.In);
\r
412 public static FlagClass.Type toFlagType(DiagramResource dr, Resource type, FlagClass.Type defaultValue) {
\r
413 if (type != null) {
\r
414 if (dr.FlagType_InputFlag.equals(type))
\r
416 if (dr.FlagType_OutputFlag.equals(type))
\r
419 return defaultValue;
\r
422 public static void tag(WriteGraph g, Resource object, Resource tag, boolean set) throws DatabaseException {
\r
424 g.claim(object, tag, tag, object);
\r
426 g.deny(object, tag, tag, object);
\r
431 * @param diagram the diagram from which to look for a page description
\r
433 * @return if the diagram does not have a page desc definition,
\r
434 * <code>defaultValue</code> is returned
\r
435 * @throws DatabaseException
\r
437 public static PageDesc getPageDesc(ReadGraph graph, Resource diagram, PageDesc defaultValue) throws DatabaseException {
\r
438 DiagramResource dr = DiagramResource.getInstance(graph);
\r
439 Resource pd = graph.getPossibleObject(diagram, dr.HasPageDescription);
\r
441 return defaultValue;
\r
442 return readPageDesc(graph, pd);
\r
448 * the diagram from which to look for a page description property
\r
449 * @return PageDesc for the specified diagram
\r
450 * @throws DatabaseException
\r
451 * if DIA.HasPageDescription can't be read
\r
453 public static PageDesc getPageDesc(ReadGraph graph, Resource diagram) throws DatabaseException {
\r
454 DiagramResource dr = DiagramResource.getInstance(graph);
\r
455 Resource pd = graph.getSingleObject(diagram, dr.HasPageDescription);
\r
456 return readPageDesc(graph, pd);
\r
459 public static PageDesc readPageDesc(ReadGraph graph, Resource pageDesc) throws DatabaseException {
\r
460 Layer0 l0 = Layer0.getInstance(graph);
\r
461 DiagramResource dr = DiagramResource.getInstance(graph);
\r
462 Resource orientation = graph.getSingleObject(pageDesc, dr.PageDescription_Orientation);
\r
463 double[] size = graph.getRelatedValue(pageDesc, dr.PageDescription_Size, Bindings.getBindingUnchecked(double[].class));
\r
464 Resource margins = graph.getSingleObject(pageDesc, dr.PageDescription_Margins);
\r
465 Margins m = readMargins(graph, margins);
\r
466 //PageDesc pd = PageDesc.getDescription(toOrientation(orientation, dr), size[0], size[1]);
\r
467 String name = graph.getPossibleRelatedValue(pageDesc, l0.HasName);
\r
470 PageDesc pd = new PageDesc(name, toOrientation(orientation, dr), PageCentering.TopLeftAtOrigin, size[0], size[1], m);
\r
474 public static Margins readMargins(ReadGraph graph, Resource margins) throws NoSingleResultException, DoesNotContainValueException, ServiceException {
\r
475 DiagramResource dr = DiagramResource.getInstance(graph);
\r
476 double t = graph.getRelatedValue(margins, dr.PageDescription_Margins_Top);
\r
477 double b = graph.getRelatedValue(margins, dr.PageDescription_Margins_Bottom);
\r
478 double l = graph.getRelatedValue(margins, dr.PageDescription_Margins_Left);
\r
479 double r = graph.getRelatedValue(margins, dr.PageDescription_Margins_Right);
\r
480 Margin mt = new Margin(0, 0, t);
\r
481 Margin mb = new Margin(0, 0, b);
\r
482 Margin ml = new Margin(0, 0, l);
\r
483 Margin mr = new Margin(0, 0, r);
\r
484 return new Margins(mt, mb, ml, mr);
\r
487 public static void setPageDesc(WriteGraph graph, Resource diagram, String pageDescRepr) throws DatabaseException {
\r
488 setPageDesc(graph, diagram, PageDesc.fromRepr(pageDescRepr));
\r
491 public static void setPageDesc(WriteGraph graph, Resource diagram, PageDesc pageDesc) throws DatabaseException {
\r
492 Layer0 b = Layer0.getInstance(graph);
\r
493 G2DResource g2d = G2DResource.getInstance(graph);
\r
494 DiagramResource dr = DiagramResource.getInstance(graph);
\r
495 Resource pd = graph.getPossibleObject(diagram, dr.HasPageDescription);
\r
496 if(pd != null && graph.isImmutable(pd)) {
\r
497 graph.deny(diagram, dr.HasPageDescription);
\r
501 pd = graph.newResource();
\r
502 graph.claim(pd, b.InstanceOf, null, dr.PageDescription);
\r
503 graph.claim(diagram, dr.HasPageDescription, pd);
\r
505 graph.deny(pd, dr.PageDescription_Size);
\r
506 Resource pageSize = graph.newResource();
\r
507 graph.claim(pageSize, b.InstanceOf, null, g2d.Point2D);
\r
508 graph.claimValue(pageSize, new double[] { pageDesc.getWidth(), pageDesc.getHeight() });
\r
509 graph.claim(pd, dr.PageDescription_Size, pageSize);
\r
510 graph.deny(pd, dr.PageDescription_Orientation);
\r
511 graph.claim(pd, dr.PageDescription_Orientation, toOrientationResource(pageDesc.getOrientation(), dr));
\r
512 Resource margins = graph.getPossibleObject(pd, dr.PageDescription_Margins);
\r
513 if (margins == null) {
\r
514 margins = graph.newResource();
\r
515 graph.claim(margins, b.InstanceOf, null, dr.Margins);
\r
516 graph.claim(pd, dr.PageDescription_Margins, margins);
\r
518 setMargins(graph,pageDesc.getMargins(),margins, dr);
\r
519 graph.claimLiteral(pd, b.HasName,pageDesc.getText());
\r
522 private static PageOrientation toOrientation(Resource orientation, DiagramResource dr) {
\r
523 if (orientation != null) {
\r
524 if (orientation.equals(dr.Orientation_Portrait))
\r
525 return PageOrientation.Portrait;
\r
526 if (orientation.equals(dr.Orientation_Landscape))
\r
527 return PageOrientation.Landscape;
\r
529 return PageOrientation.Portrait;
\r
532 public static Resource toOrientationResource(PageOrientation orientation, DiagramResource dr) {
\r
533 if (PageOrientation.Portrait.equals(orientation))
\r
534 return dr.Orientation_Portrait;
\r
535 if (PageOrientation.Landscape.equals(orientation))
\r
536 return dr.Orientation_Landscape;
\r
537 return dr.Orientation_Portrait;
\r
540 private static void setMargins(WriteGraph g, Margins margins, Resource marginsR,DiagramResource dr) throws ServiceException, ManyObjectsForFunctionalRelationException {
\r
542 g.claimLiteral(marginsR, dr.PageDescription_Margins_Top,margins.top.diagramAbsolute);
\r
543 g.claimLiteral(marginsR, dr.PageDescription_Margins_Bottom,margins.bottom.diagramAbsolute);
\r
544 g.claimLiteral(marginsR, dr.PageDescription_Margins_Left,margins.left.diagramAbsolute);
\r
545 g.claimLiteral(marginsR, dr.PageDescription_Margins_Right,margins.right.diagramAbsolute);
\r
549 public static Double getGridSize(ReadGraph graph, Resource diagram, Double defaultValue) throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
550 DiagramResource dr = DiagramResource.getInstance(graph);
\r
551 Double gridSize = graph.getPossibleRelatedValue(diagram, dr.HasGridSize);
\r
552 return gridSize == null ? defaultValue : gridSize;
\r
555 public static void setGridSize(WriteGraph graph, Resource diagram, double gridSize) throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
556 DiagramResource dr = DiagramResource.getInstance(graph);
\r
557 graph.claimLiteral(diagram, dr.HasGridSize, gridSize);
\r
560 public static boolean isPageBordersVisible(ReadGraph graph, Resource diagram) throws DatabaseException {
\r
561 DiagramResource dr = DiagramResource.getInstance(graph);
\r
562 return graph.hasStatement(diagram, dr.DisplayPageSize);
\r
565 public static boolean isMarginsVisible(ReadGraph graph, Resource diagram) throws DatabaseException {
\r
566 DiagramResource dr = DiagramResource.getInstance(graph);
\r
567 return graph.hasStatement(diagram, dr.DisplayMargins);
\r
570 public static void setPageBordersVisible(WriteGraph graph, Resource diagram, boolean visible) throws DatabaseException {
\r
571 DiagramResource dr = DiagramResource.getInstance(graph);
\r
572 tag(graph, diagram, dr.DisplayPageSize, visible);
\r
575 public static void setMarginsVisible(WriteGraph graph, Resource diagram, boolean visible) throws DatabaseException {
\r
576 DiagramResource dr = DiagramResource.getInstance(graph);
\r
577 tag(graph, diagram, dr.DisplayMargins, visible);
\r
580 public static void setDiagramDesc(WriteGraph graph, Resource diagram, DiagramDesc desc) throws DatabaseException {
\r
581 DiagramGraphUtil.setPageDesc(graph, diagram, desc.getPageDesc());
\r
582 DiagramGraphUtil.setGridSize(graph, diagram, desc.getGridSize());
\r
583 DiagramGraphUtil.setPageBordersVisible(graph, diagram, desc.isPageBordersVisible());
\r
584 DiagramGraphUtil.setMarginsVisible(graph, diagram, desc.isMarginsVisible());
\r
585 // Add comment to change set.
\r
586 CommentMetadata cm = graph.getMetadata(CommentMetadata.class);
\r
587 graph.addMetadata(cm.add("Set diagram description for diagram resource " + diagram));
\r
591 * Potentially returns the connection connected to the element with the
\r
592 * given connectionRelation.
\r
594 public static Resource getRelatedConnection(ReadGraph g, Resource element, Resource connectionRelation) throws DatabaseException {
\r
595 StructuralResource2 sr = StructuralResource2.getInstance(g);
\r
596 for(Resource connector : g.getObjects(element, connectionRelation))
\r
597 for(Resource connection : g.getObjects(connector, sr.Connects))
\r
598 if(!connection.equals(element))
\r
604 * Returns the connection type of a potential connection connected to the
\r
605 * element with the given connectionRelation.
\r
607 public static Resource getRelatedConnectionType(ReadGraph g, Resource element, Resource connectionRelation) throws DatabaseException {
\r
608 StructuralResource2 sr = StructuralResource2.getInstance(g);
\r
609 for(Resource connector : g.getObjects(element, connectionRelation))
\r
610 for(Resource connection : g.getObjects(connector, sr.Connects))
\r
611 if(!connection.equals(element))
\r
612 for(Resource connectionType : g.getObjects(connection, sr.HasConnectionType))
\r
613 return connectionType;
\r
618 * Returns a flag that is joined to this flag with a ConnectionJoin.
\r
620 public static Resource getJoinedFlag(ReadGraph g, Resource flag) throws DatabaseException {
\r
621 DiagramResource dr = DiagramResource.getInstance(g);
\r
622 for(Resource join : g.getObjects(flag, dr.FlagIsJoinedBy))
\r
623 for(Resource otherFlag : g.getObjects(join, dr.JoinsFlag))
\r
624 if(!otherFlag.equals(flag))
\r
629 public static Resource getConnectionTypeForFlag(ReadGraph g, Resource flag) throws DatabaseException {
\r
630 DiagramResource dr = DiagramResource.getInstance(g);
\r
632 Resource connectionType = getRelatedConnectionType(g, flag, dr.Flag_ConnectionPoint);
\r
633 if(connectionType != null)
\r
634 return connectionType;
\r
636 Resource otherFlag = getJoinedFlag(g, flag);
\r
637 if(otherFlag == null)
\r
640 return getRelatedConnectionType(g, otherFlag, dr.Flag_ConnectionPoint);
\r
644 * Checks if the two specified diagram elements exist on the same diagram.
\r
646 public static boolean onSameDiagram(ReadGraph graph, Resource element1, Resource element2) throws DatabaseException {
\r
647 return !Collections.disjoint(
\r
648 OrderedSetElementsPredicate.INSTANCE.getSubjects(graph, element1),
\r
649 OrderedSetElementsPredicate.INSTANCE.getSubjects(graph, element2));
\r
653 * Checks whether a diagram element has a <code>DIAGRAM.Routing</code> tag
\r
654 * that is adaptable to {@link IRouter2}.
\r
660 public static void getPossibleRouter(AsyncReadGraph graph, final Resource element, final AsyncProcedure<IRouter2> procedure) {
\r
661 DiagramResource dr = graph.getService(DiagramResource.class);
\r
662 graph.forPossibleStatement(element, dr.Routing, new AsyncProcedure<Statement>() {
\r
664 public void exception(AsyncReadGraph graph, Throwable throwable) {
\r
665 procedure.exception(graph, throwable);
\r
668 public void execute(AsyncReadGraph graph, Statement result) {
\r
669 if (result != null)
\r
670 graph.forPossibleAdapted(result.getPredicate(), IRouter2.class, procedure);
\r
672 procedure.execute(graph, null);
\r
679 * @param modelingRules
\r
680 * @param connection
\r
683 * @param firstTerminal
\r
684 * @param secondTerminal
\r
685 * @throws DatabaseException
\r
687 public static void loadConnectionVisuals(ReadGraph graph, IModelingRules modelingRules, Resource connection,
\r
688 IDiagram diagram, IElement edge, DesignatedTerminal firstTerminal, DesignatedTerminal secondTerminal)
\r
689 throws DatabaseException {
\r
690 List<EdgeVisuals> evs = edge.getElementClass().getItemsByClass(EdgeVisuals.class);
\r
694 IAttachmentRelationMap attachmentRelations = modelingRules.getAttachmentRelations(graph, connection);
\r
696 IConnectionPoint firstCp = ConnectionUtil.toConnectionPoint(graph, firstTerminal);
\r
697 IConnectionPoint secondCp = ConnectionUtil.toConnectionPoint(graph, secondTerminal);
\r
699 Resource firstAttachment = null;
\r
700 Resource secondAttachment = null;
\r
702 if (firstCp instanceof CPTerminal)
\r
703 firstAttachment = attachmentRelations.get(graph, (CPTerminal) firstCp);
\r
704 if (secondCp instanceof CPTerminal)
\r
705 secondAttachment = attachmentRelations.get(graph, (CPTerminal) secondCp);
\r
707 if (DebugPolicy.DEBUG_CONNECTION_VISUALS_LOAD) {
\r
708 System.out.println("first attachment relation : " + NameUtils.getSafeName(graph, firstAttachment));
\r
709 System.out.println("second attachment relation : " + NameUtils.getSafeName(graph, secondAttachment));
\r
712 // 1. Configure edge ends
\r
713 loadEdgeEnds(graph, modelingRules, connection, edge, firstAttachment, secondAttachment);
\r
715 // 2. Configure edge line style
\r
716 loadLineStyle(graph, modelingRules, connection, edge);
\r
719 public static void loadEdgeEnds(ReadGraph graph, IModelingRules modelingRules, Resource connection, IElement edge,
\r
720 Resource firstAttachment, Resource secondAttachment) throws DatabaseException {
\r
721 EdgeVisualsConfigurer startConfig = (firstAttachment != null) ? graph.syncRequest(Queries.adapt(
\r
722 firstAttachment, EdgeVisualsConfigurer.class, true)) : null;
\r
723 EdgeVisualsConfigurer endConfig = (secondAttachment != null) ? graph.syncRequest(Queries.adapt(
\r
724 secondAttachment, EdgeVisualsConfigurer.class, true)) : null;
\r
726 for (EdgeVisuals ev : edge.getElementClass().getItemsByClass(EdgeVisuals.class)) {
\r
727 if (startConfig != null)
\r
728 startConfig.configure(edge, ev, EdgeVisuals.BEGIN);
\r
730 ev.setArrowType(edge, EdgeEnd.Begin, ArrowType.None);
\r
731 if (endConfig != null)
\r
732 endConfig.configure(edge, ev, EdgeVisuals.END);
\r
734 ev.setArrowType(edge, EdgeEnd.End, ArrowType.None);
\r
738 public static void loadLineStyle(ReadGraph graph, IModelingRules modelingRules, Resource connection, IElement edge)
\r
739 throws DatabaseException {
\r
740 Resource connectionType = modelingRules.getConnectionType(graph, connection);
\r
741 if (connectionType != null) {
\r
742 loadLineStyleFromConnectionType(graph, modelingRules, connectionType, edge);
\r
746 public static void loadLineStyleFromConnectionType(ReadGraph graph, IModelingRules modelingRules, Resource connectionType, IElement edge)
\r
747 throws DatabaseException {
\r
748 edge.setHint(ElementHints.KEY_CONNECTION_TYPE, connectionType);
\r
749 if (DebugPolicy.DEBUG_CONNECTION_VISUALS_LOAD)
\r
750 System.out.println("Connection type : " + NameUtils.getSafeName(graph, connectionType));
\r
752 // Load standard visual aspects of the specified edge
\r
753 ConnectionVisuals cv = graph.syncRequest(DiagramRequests.getConnectionVisuals(connectionType));
\r
755 if (cv.color != null) {
\r
756 for (FillColor fc : edge.getElementClass().getItemsByClass(FillColor.class)) {
\r
757 fc.setFillColor(edge, cv.toColor());
\r
760 for (EdgeVisuals ev : edge.getElementClass().getItemsByClass(EdgeVisuals.class)) {
\r
761 if (cv.stroke != null)
\r
762 ev.setStroke(edge, cv.stroke);
\r
763 if (cv.strokeType != null)
\r
764 ev.setStrokeType(edge, cv.strokeType);
\r
770 * @param connectionPart
\r
772 * @throws DatabaseException
\r
774 public static ConnectionSegmentEnd resolveConnectionSegmentEnd(ReadGraph graph, Resource connectionPart)
\r
775 throws DatabaseException {
\r
776 BasicResources br = BasicResources.getInstance(graph);
\r
777 if (graph.isInstanceOf(connectionPart, br.DIA.BranchPoint))
\r
778 return ConnectionSegmentEnd.BRANCH;
\r
779 if (graph.isInstanceOf(connectionPart, br.DIA.Connector))
\r
780 return ConnectionSegmentEnd.CONNECTOR;
\r
787 * @param segmentEnd
\r
790 * @throws DatabaseException
\r
792 public static DesignatedTerminal findDesignatedTerminal(ReadGraph graph, IDiagram diagram, Resource segmentEnd, ConnectionSegmentEnd endType)
\r
793 throws DatabaseException {
\r
794 if (DebugPolicy.DEBUG_TERMINAL_SEARCH)
\r
795 System.out.println("findDesignatedTerminal: " + NameUtils.getSafeName(graph, segmentEnd) + " : " + endType);
\r
797 BasicResources br = BasicResources.getInstance(graph);
\r
798 DataElementMap dem = diagram.getDiagramClass().getSingleItem(DataElementMap.class);
\r
802 List<Terminal> ts = new ArrayList<Terminal>();
\r
803 for (Statement stm : graph.getStatements(segmentEnd, br.STR.Connects)) {
\r
804 // Ignore the Is Connector Of relation that goes to the
\r
805 // owner :Connection
\r
806 if (graph.isSubrelationOf(stm.getPredicate(), br.DIA.IsConnectorOf))
\r
809 Resource connectionRelation = graph.getInverse(stm.getPredicate());
\r
810 if (DebugPolicy.DEBUG_TERMINAL_SEARCH)
\r
811 System.out.println("CONNECTION RELATION: " + NameUtils.getSafeName(graph, connectionRelation));
\r
812 Resource elementResource = stm.getObject();
\r
813 if (DebugPolicy.DEBUG_TERMINAL_SEARCH)
\r
814 System.out.println("ELEMENT RESOURCE: " + NameUtils.getSafeName(graph, elementResource));
\r
815 IElement e = dem.getElement(diagram, elementResource);
\r
818 // throw new ValidationException("connector "
\r
819 // + NameUtils.getSafeName(graph, segmentEnd)
\r
820 // + " is connected to an entity that has not (yet) been loaded as an IElement: "
\r
821 // + NameUtils.getSafeName(graph, elementResource));
\r
824 TerminalTopology tt = e.getElementClass().getSingleItem(TerminalTopology.class);
\r
826 tt.getTerminals(e, ts);
\r
827 for (Terminal t : ts) {
\r
828 if (t instanceof ResourceTerminal) {
\r
829 ResourceTerminal rt = (ResourceTerminal) t;
\r
830 Resource binds = DiagramGraphUtil.getConnectionPointOfTerminal(graph, rt.getResource());
\r
831 if (DebugPolicy.DEBUG_TERMINAL_SEARCH) {
\r
832 System.out.println("connection relation: "
\r
833 + NameUtils.getSafeName(graph, connectionRelation) + " " + connectionRelation.getResourceId());
\r
834 System.out.println(" terminal: " + NameUtils.getSafeName(graph, rt.getResource()) + " " + rt.getResource().getResourceId());
\r
835 System.out.println(" binds: " + NameUtils.getSafeName(graph, binds) + " " + binds.getResourceId());
\r
837 if (graph.isSubrelationOf(connectionRelation, binds)) {
\r
838 return new DesignatedTerminal(e, t);
\r
843 throw new ValidationException("connector "
\r
844 + NameUtils.getSafeName(graph, segmentEnd)
\r
845 + " is connected using a relation that is not its own: "
\r
846 + NameUtils.getSafeName(graph, connectionRelation));
\r
849 // ValidationException("connector " +
\r
850 // NameUtils.getSafeName(g, segmentEnd) +
\r
851 // " is not connected to anything");
\r
855 List<Terminal> ts = new ArrayList<Terminal>();
\r
856 IElement e = dem.getElement(diagram, segmentEnd);
\r
858 // throw new ValidationException("branch point "
\r
859 // + NameUtils.getSafeName(graph, segmentEnd)
\r
860 // + " has not (yet) been loaded as an IElement");
\r
864 TerminalTopology tt = e.getElementClass().getSingleItem(TerminalTopology.class);
\r
865 tt.getTerminals(e, ts);
\r
866 if (ts.size() != 1)
\r
867 throw new IllegalStateException("branch point element has " + ts.size()
\r
868 + " terminals, expected 1");
\r
869 return new DesignatedTerminal(e, ts.get(0));
\r
872 throw new IllegalArgumentException("unexpected connection segment end: " + endType);
\r
879 * @param terminalStm the statement that goes from the connection
\r
880 * connector to the node with inverse relation of the terminal
\r
883 * @throws DatabaseException
\r
885 public static DesignatedTerminal getDesignatedTerminalForConnector(ReadGraph graph, IDiagram diagram, Resource elementResource, Resource terminalRelation, Resource connector)
\r
886 throws DatabaseException {
\r
887 if (DebugPolicy.DEBUG_TERMINAL_SEARCH)
\r
888 System.out.println("getDesignatedTerminalForConnector: ("
\r
889 + NameUtils.getSafeName(graph, elementResource) + ", "
\r
890 + NameUtils.getSafeName(graph, terminalRelation) + ", "
\r
891 + NameUtils.getSafeName(graph, connector) + ")"
\r
894 DataElementMap dem = diagram.getDiagramClass().getSingleItem(DataElementMap.class);
\r
895 IElement e = dem.getElement(diagram, elementResource);
\r
899 TerminalTopology tt = e.getElementClass().getSingleItem(TerminalTopology.class);
\r
900 List<Terminal> ts = new ArrayList<Terminal>();
\r
901 tt.getTerminals(e, ts);
\r
902 for (Terminal t : ts) {
\r
903 if (t instanceof ResourceTerminal) {
\r
904 ResourceTerminal rt = (ResourceTerminal) t;
\r
905 Resource binds = DiagramGraphUtil.getConnectionPointOfTerminal(graph, rt.getResource());
\r
906 if (DebugPolicy.DEBUG_TERMINAL_SEARCH) {
\r
907 System.out.println("connection relation: "
\r
908 + NameUtils.getSafeName(graph, terminalRelation, true));
\r
909 System.out.println(" terminal: " + NameUtils.getSafeName(graph, rt.getResource(), true));
\r
910 System.out.println(" binds: " + NameUtils.getSafeName(graph, binds, true));
\r
912 if (graph.isSubrelationOf(terminalRelation, binds)) {
\r
913 return new DesignatedTerminal(e, t);
\r
918 throw new ValidationException("terminal connection statement ("
\r
919 + NameUtils.getSafeName(graph, elementResource) + ", "
\r
920 + NameUtils.getSafeName(graph, terminalRelation) + ", "
\r
921 + NameUtils.getSafeName(graph, connector) + ")"
\r
922 + " is using using a terminal relation that is not its own: "
\r
923 + NameUtils.getSafeName(graph, terminalRelation));
\r
929 * @throws DatabaseException
\r
931 public static TerminalMap getElementTerminals(ReadGraph graph, Resource element)
\r
932 throws DatabaseException {
\r
933 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
934 Resource elementType = graph.getPossibleType(element, DIA.Element);
\r
935 return elementType != null ? getElementTypeTerminals(graph, elementType) : TerminalMap.EMPTY;
\r
938 private static final boolean DEBUG_GET_ELEMENT_TYPE_TERMINALS = false;
\r
942 * @param elementType
\r
944 * @throws DatabaseException
\r
946 public static TerminalMap getElementTypeTerminals(ReadGraph graph, Resource elementType) throws DatabaseException {
\r
947 StructuralResource2 STR = StructuralResource2.getInstance(graph);
\r
948 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
949 if (DEBUG_GET_ELEMENT_TYPE_TERMINALS)
\r
950 System.out.println("getElementTypeTerminals: " + NameUtils.getSafeName(graph, elementType));
\r
951 Resource definedBy = graph.getSingleObject(elementType, STR.IsDefinedBy);
\r
952 Collection<Resource> parts = OrderedSetUtils.toList(graph, definedBy);
\r
953 if (DEBUG_GET_ELEMENT_TYPE_TERMINALS)
\r
954 System.out.println("\tdefining part count: " + parts.size());
\r
955 TerminalMap result = null;
\r
956 for (Resource part : parts) {
\r
957 if (DEBUG_GET_ELEMENT_TYPE_TERMINALS)
\r
958 System.out.println("\t\tpart: " + NameUtils.getSafeName(graph, part));
\r
959 if (graph.isInstanceOf(part, DIA.Terminal)) {
\r
960 Resource binds = DiagramGraphUtil.getConnectionPointOfTerminal(graph, part);
\r
961 if (result == null)
\r
962 result = new TerminalMap(parts.size());
\r
963 if (DEBUG_GET_ELEMENT_TYPE_TERMINALS)
\r
964 System.out.println("\t\t\tFOUND TERMINAL <-> BINDING RELATION: " + NameUtils.getSafeName(graph, part) + " <-> " + NameUtils.getSafeName(graph, binds));
\r
965 result.put(part, binds);
\r
968 return result != null ? result : TerminalMap.EMPTY;
\r
972 * Get the value of a specified on/off diagram preference setting (=tag)
\r
973 * where the tag may be stored in:
\r
975 * <li>The diagram itself</li>
\r
976 * <li>The model</li>
\r
977 * <li>The project</li>
\r
980 * @param graph database access
\r
981 * @param diagram the diagram to look for the tag in
\r
982 * @param preference the tag relation of the boolean preference to check for
\r
983 * @return value of the preference
\r
984 * @throws DatabaseException
\r
986 public static boolean getDiagramTagPreference(ReadGraph graph, Resource diagram, Resource preference) throws DatabaseException {
\r
987 boolean result = graph.hasStatement(diagram, preference);
\r
989 Resource model = graph.sync(new PossibleModel(diagram));
\r
991 result = graph.hasStatement(model, preference);
\r
993 result = graph.hasStatement(Simantics.getProjectResource(), preference);
\r
998 public static void rotateConnection(WriteGraph graph, Resource r,
\r
999 double cx, double cy, boolean clockwise) throws DatabaseException {
\r
1000 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
1001 for(Resource node : graph.getObjects(r, DIA.HasInteriorRouteNode))
\r
1002 if(graph.isInstanceOf(node, DIA.RouteLine)) {
\r
1003 boolean isHorizontal = (Boolean)graph.getRelatedValue(node, DIA.IsHorizontal);
\r
1004 double position = (Double)graph.getRelatedValue(node, DIA.HasPosition);
\r
1006 if(isHorizontal) {
\r
1009 position = -position;
\r
1015 position = -position;
\r
1018 isHorizontal = !isHorizontal;
\r
1020 graph.claimLiteral(node, DIA.IsHorizontal, isHorizontal);
\r
1021 graph.claimLiteral(node, DIA.HasPosition, position);
\r
1025 public static void flipConnection(WriteGraph graph, Resource r,
\r
1026 boolean xAxis, double c) throws DatabaseException {
\r
1027 DiagramResource DIA = DiagramResource.getInstance(graph);
\r
1028 for(Resource node : graph.getObjects(r, DIA.HasInteriorRouteNode))
\r
1029 if(graph.isInstanceOf(node, DIA.RouteLine)) {
\r
1030 boolean isHorizontal = (Boolean)graph.getRelatedValue(node, DIA.IsHorizontal);
\r
1032 if(isHorizontal == xAxis) {
\r
1033 double position = (Double)graph.getRelatedValue(node, DIA.HasPosition);
\r
1034 position = 2*c-position;
\r
1035 graph.claimLiteral(node, DIA.HasPosition, position);
\r
1040 /*public static void addConnectionPoint(WriteGraph g, Resource symbol, Resource terminal,
\r
1041 Resource diagramConnectionRelation) throws DatabaseException {
\r
1042 Layer0 L0 = Layer0.getInstance(g);
\r
1043 StructuralResource2 STR = StructuralResource2.getInstance(g);
\r
1044 DiagramResource DIA = DiagramResource.getInstance(g);
\r
1046 Resource variable = g.newResource();
\r
1047 g.claim(variable, L0.InstanceOf, null, STR.ConnectionVariable);
\r
1048 g.claim(terminal, DIA.HasConnectionVariable, variable);
\r
1049 g.claim(variable, STR.Binds, diagramConnectionRelation);
\r
1050 g.claim(variable, STR.IsParameterOf, symbol);
\r
1054 public static Resource getConnectionPointOfTerminal(ReadGraph g, Resource forTerminal) throws DatabaseException {
\r
1055 return g.getSingleObject(
\r
1056 g.getSingleObject(forTerminal, DiagramResource.getInstance(g).HasConnectionVariable),
\r
1057 StructuralResource2.getInstance(g).Binds);
\r
1060 public static Resource getPossibleConnectionPointOfTerminal(ReadGraph g, Resource forTerminal) throws DatabaseException {
\r
1061 Resource connectionVariable = g.getPossibleObject(forTerminal, DiagramResource.getInstance(g).HasConnectionVariable);
\r
1062 return (connectionVariable == null) ? null : g.getPossibleObject(connectionVariable, StructuralResource2.getInstance(g).Binds);
\r
1065 public static void addConnectionPoint(WriteGraph g, Resource symbol, Resource terminal,
\r
1066 Resource diagramConnectionRelation) throws DatabaseException {
\r
1067 Layer0 L0 = Layer0.getInstance(g);
\r
1068 DiagramResource DIA = DiagramResource.getInstance(g);
\r
1070 g.claim(terminal, DIA.HasConnectionPoint, diagramConnectionRelation);
\r
1071 g.claim(diagramConnectionRelation, L0.HasDomain, symbol);
\r
1075 public static Resource getConnectionPointOfTerminal(ReadGraph g, Resource forTerminal) throws DatabaseException {
\r
1076 return g.getSingleObject(forTerminal, DiagramResource.getInstance(g).HasConnectionPoint);
\r
1079 public static Resource getPossibleConnectionPointOfTerminal(ReadGraph g, Resource forTerminal) throws DatabaseException {
\r
1080 return g.getPossibleObject(forTerminal, DiagramResource.getInstance(g).HasConnectionPoint);
\r
1083 public static Collection<Resource> getTerminals(ReadGraph g, Resource symbol) throws DatabaseException {
\r
1084 // Layer0 L0 = Layer0.getInstance(g);
\r
1085 StructuralResource2 STR = StructuralResource2.getInstance(g);
\r
1086 DiagramResource DIA = DiagramResource.getInstance(g);
\r
1087 List<Resource> terminals = null;
\r
1088 for (Resource definedBy : g.getObjects(symbol, STR.IsDefinedBy)) {
\r
1089 Collection<Resource> elements = g.syncRequest( new OrderedSet(definedBy) );
\r
1090 if (terminals == null)
\r
1091 terminals = new ArrayList<Resource>( elements.size() );
\r
1092 for (Resource element : elements)
\r
1093 if (g.isInstanceOf(element, DIA.Terminal))
\r
1094 terminals.add(element);
\r
1096 // Collection<Resource> definedBy = g.getObjects(symbol, STR.IsDefinedBy);
\r
1097 // if (!definedBy.isEmpty()) {
\r
1098 // Collection<Resource> relations = g.getObjects(symbol, L0.DomainOf);
\r
1099 // terminals = new ArrayList<Resource>(relations.size());
\r
1100 // for(Resource relation : relations) {
\r
1101 // for (Resource element : g.getObjects(relation, DIA.HasConnectionPoint_Inverse)) {
\r
1102 // Collection<Resource> owners = OrderedSetUtils.getOwnerLists(g, element, DIA.Diagram);
\r
1103 // if (!Collections.disjoint(definedBy, owners))
\r
1104 // terminals.add(element);
\r
1108 return terminals == null ? Collections.<Resource>emptyList() : terminals;
\r
1112 * Determines the connection type of the given diagram connection. Uses the modeling rules
\r
1113 * specified in the diagram the connection belongs to.
\r
1115 public static Resource determineConnectionType(ReadGraph graph, Resource diagramConnection) throws DatabaseException {
\r
1116 Layer0 L0 = Layer0.getInstance(graph);
\r
1117 Resource diagram = graph.getPossibleObject(diagramConnection, L0.PartOf);
\r
1118 if (diagram == null)
\r
1119 // Invalid diagram connection resource, not a part of any diagram.
\r
1121 IModelingRules modelingRules = graph.syncRequest(DiagramRequests.getModelingRules(diagram, null));
\r
1122 if (modelingRules == null)
\r
1124 return determineConnectionType(graph, diagramConnection, modelingRules);
\r
1128 * Determines the connection type of the given diagram connection assuming the given modeling rules.
\r
1130 public static Resource determineConnectionType(ReadGraph graph, Resource diagramConnection, IModelingRules modelingRules) throws DatabaseException {
\r
1132 Set<IConnectionPoint> cps = new THashSet<IConnectionPoint>();
\r
1133 DiagramRequests.expandConnections(graph, diagramConnection, new THashSet<Resource>(), cps);
\r
1134 return modelingRules.computeConnectionType(graph, cps);
\r
1138 public static void defaultSymbolDropHandler(WriteGraph graph, List<WorkbenchSelectionElement> drop) throws DatabaseException {
\r
1139 System.err.println("dropped " + drop);
\r