7d9d1dba8b02bfcddc51526ff42a6f0491940949
[simantics/platform.git] / bundles / org.simantics.selectionview / src / org / simantics / selectionview / function / All.java
1 package org.simantics.selectionview.function;
2
3 import java.io.IOException;
4 import java.util.ArrayList;
5 import java.util.Map;
6 import java.util.function.Consumer;
7
8 import org.eclipse.swt.graphics.FontData;
9 import org.eclipse.swt.graphics.RGB;
10 import org.eclipse.swt.widgets.ColorDialog;
11 import org.eclipse.swt.widgets.Control;
12 import org.eclipse.swt.widgets.FontDialog;
13 import org.simantics.Simantics;
14 import org.simantics.browsing.ui.NodeContext;
15 import org.simantics.browsing.ui.content.Labeler.DialogModifier;
16 import org.simantics.common.format.Formatter;
17 import org.simantics.databoard.Bindings;
18 import org.simantics.databoard.Datatypes;
19 import org.simantics.databoard.adapter.AdaptException;
20 import org.simantics.databoard.binding.Binding;
21 import org.simantics.databoard.binding.NumberBinding;
22 import org.simantics.databoard.binding.StringBinding;
23 import org.simantics.databoard.binding.error.BindingConstructionException;
24 import org.simantics.databoard.binding.error.BindingException;
25 import org.simantics.databoard.binding.mutable.MutableStringBinding;
26 import org.simantics.databoard.binding.mutable.Variant;
27 import org.simantics.databoard.parser.DataValuePrinter;
28 import org.simantics.databoard.parser.repository.DataTypeSyntaxError;
29 import org.simantics.databoard.parser.repository.DataValueRepository;
30 import org.simantics.databoard.primitives.MutableString;
31 import org.simantics.databoard.type.Datatype;
32 import org.simantics.databoard.util.ObjectUtils;
33 import org.simantics.datatypes.literal.Font;
34 import org.simantics.db.ReadGraph;
35 import org.simantics.db.Resource;
36 import org.simantics.db.Statement;
37 import org.simantics.db.WriteGraph;
38 import org.simantics.db.common.CommentMetadata;
39 import org.simantics.db.common.request.EnumerationMap;
40 import org.simantics.db.common.request.InstanceEnumerationMap;
41 import org.simantics.db.common.request.IsEnumeratedValue;
42 import org.simantics.db.common.request.UniqueRead;
43 import org.simantics.db.common.request.WriteRequest;
44 import org.simantics.db.common.utils.NameUtils;
45 import org.simantics.db.exception.DatabaseException;
46 import org.simantics.db.layer0.util.Layer0Utils;
47 import org.simantics.db.layer0.variable.ValueAccessor;
48 import org.simantics.db.layer0.variable.Variable;
49 import org.simantics.db.layer0.variable.Variables;
50 import org.simantics.layer0.Layer0;
51 import org.simantics.modeling.ModelingResources;
52 import org.simantics.scl.compiler.types.TVar;
53 import org.simantics.scl.compiler.types.Type;
54 import org.simantics.scl.compiler.types.Types;
55 import org.simantics.scl.reflection.annotations.SCLValue;
56 import org.simantics.selectionview.SelectionInput;
57 import org.simantics.selectionview.StandardSelectionInput;
58 import org.simantics.ui.colors.Colors;
59 import org.simantics.ui.fonts.Fonts;
60 import org.simantics.ui.selection.WorkbenchSelectionElement;
61 import org.simantics.ui.selection.WorkbenchSelectionUtils;
62 import org.simantics.utils.datastructures.collections.CollectionUtils;
63 import org.simantics.utils.ui.AdaptionUtils;
64 import org.simantics.utils.ui.ErrorLogger;
65 import org.simantics.utils.ui.ISelectionUtils;
66
67 public class All {
68
69         final private static Binding datatype_binging = Bindings.getBindingUnchecked(Datatype.class);
70
71         @SCLValue(type = "ReadGraph -> Resource -> Variable -> b")
72         public static Object colorModifier(ReadGraph graph, Resource resource, final Variable context) throws DatabaseException {
73                 return new DialogModifier() {
74
75                         @Override
76                         public String getValue() {
77                                 return null;
78                         }
79
80                         @Override
81                         public String isValid(String label) {
82                                 return null;
83                         }
84
85                         @Override
86                         public void modify(final String label) {
87                                 Simantics.getSession().async(new WriteRequest() {
88
89                                         @Override
90                                         public void perform(WriteGraph graph) throws DatabaseException {
91                                                 Variable displayValue = context.getParent(graph);
92                                                 displayValue.setValue(graph, label, org.simantics.datatypes.literal.RGB.Integer.BINDING);
93                                         }
94
95                                 });
96                         }
97
98                         public String query(Object parentControl, Object controlItem, int columnIndex, NodeContext context, Consumer<String> applyCallback) {
99                                 Control ctrl = (Control) parentControl;
100
101                                 RGB initialValue = null;
102                                 final Variable v = AdaptionUtils.adaptToSingle(context, Variable.class);
103                                 if (v != null) {
104                                         try {
105                                                 org.simantics.datatypes.literal.RGB.Integer rgb = Simantics.getSession().syncRequest(new UniqueRead<org.simantics.datatypes.literal.RGB.Integer>() {
106                                                         @Override
107                                                         public org.simantics.datatypes.literal.RGB.Integer perform(ReadGraph graph) throws DatabaseException {
108                                                                 return v.getPossibleValue(graph, org.simantics.datatypes.literal.RGB.Integer.BINDING);
109                                                         }
110                                                 });
111                                                 if (rgb != null) {
112                                                         initialValue = Colors.rgb(rgb);
113                                                 }
114                                         } catch (DatabaseException e) {
115                                                 ErrorLogger.defaultLogError(e);
116                                         }
117                                 }
118
119                                 ColorDialog dialog = new ColorDialog(ctrl.getShell());
120                                 if (initialValue != null)
121                                         dialog.setRGB(initialValue);
122                                 RGB rgb = dialog.open();
123                                 if (rgb != null)
124                                         applyCallback.accept("(" + rgb.red + "," + rgb.green + "," + rgb.blue + ")");
125                                 return null;
126                         }
127
128                 };
129         }
130
131         @SCLValue(type = "ReadGraph -> Resource -> Variable -> b")
132         public static Object fontModifier(ReadGraph graph, Resource resource, final Variable context) throws DatabaseException {
133                 return new DialogModifier() {
134
135                         @Override
136                         public String getValue() {
137                                 return null;
138                         }
139
140                         @Override
141                         public String isValid(String label) {
142                                 return null;
143                         }
144
145                         @Override
146                         public void modify(final String label) {
147                                 Simantics.getSession().async(new WriteRequest() {
148
149                                         @Override
150                                         public void perform(WriteGraph graph) throws DatabaseException {
151                                                 Variable displayValue = context.getParent(graph);
152                                                 displayValue.setValue(graph, label, Font.BINDING);
153                                         }
154
155                                 });
156                         }
157
158                         public String query(Object parentControl, Object controlItem, int columnIndex, NodeContext context, Consumer<String> applyCallback) {
159                                 Control ctrl = (Control) parentControl;
160
161                                 FontData[] initialValue = null;
162                                 final Variable v = AdaptionUtils.adaptToSingle(context, Variable.class);
163                                 if (v != null) {
164                                         try {
165                                                 Font font = Simantics.getSession().syncRequest(new UniqueRead<Font>() {
166                                                         @Override
167                                                         public Font perform(ReadGraph graph) throws DatabaseException {
168                                                                 return v.getPossibleValue(graph, Font.BINDING);
169                                                         }
170                                                 });
171                                                 if (font != null) {
172                                                         initialValue = new FontData[] { Fonts.swtFontData(font) };
173                                                 }
174                                         } catch (DatabaseException e) {
175                                                 ErrorLogger.defaultLogError(e);
176                                         }
177                                 }
178
179                                 FontDialog dialog = new FontDialog(ctrl.getShell());
180                                 if (initialValue != null)
181                                         dialog.setFontList(initialValue);
182                                 FontData font = dialog.open();
183                                 if (font != null)
184                                         applyCallback.accept("(\"" + font.getName() + "\"," + font.getHeight() + ",\"" + Fonts.fromSwtStyle(font.getStyle()) + "\")");
185                                 return null;
186                         }
187
188                 };
189         }
190
191         @SCLValue(type = "ReadGraph -> Resource -> a -> b")
192         public static Object getEnumerationValues(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
193                 if(context instanceof Variable) {
194                         Layer0 L0 = Layer0.getInstance(graph);
195                         Variable parameter = ((Variable)context).browse(graph, "..");
196                         Resource parameterResource = parameter.getRepresents(graph);
197                         if(graph.sync(new IsEnumeratedValue(parameterResource))) {
198                                 Map<String, Resource> map = graph.sync(new InstanceEnumerationMap(parameterResource));
199                                 return new ArrayList<String>(map.keySet());
200                         } else if(graph.isInstanceOf(parameterResource, L0.Boolean)) {
201                                 return CollectionUtils.toList("true", "false");
202                         }
203                 }
204                 return null;
205         }
206
207         @SCLValue(type = "ReadGraph -> Resource -> a -> b")
208         public static Object getPropertyChildName(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
209                 if(context instanceof Variable) {
210                         Variable variable = (Variable)context;
211                         String label = variable.getParent(graph).getPossiblePropertyValue(graph, "HasLabel", Bindings.STRING);
212                         if(label != null)
213                                 return label;
214                         return variable.getParent(graph).getName(graph);
215                 }
216                 throw new DatabaseException("Unknown context " + context);
217         }
218         
219         @SCLValue(type = "WriteGraph -> Variable -> a -> b -> String")
220         public static String inputModifier(WriteGraph graph, Variable variable, Object value, Object _binding) throws DatabaseException {
221
222                 //      System.err.println("inputModifier " + variable.getURI(graph));
223                 Layer0 L0 = Layer0.getInstance(graph);
224
225                 Variable parent = variable.getParent(graph);
226                 Resource property = variable.getPredicateResource(graph);
227
228                 Resource container = parent.getRepresents(graph);
229                 if(container == null) return null;
230                 if(property == null) return null;
231
232                 Statement object = graph.getPossibleStatement(container, property);
233                 if(object == null) return null;
234
235                 Resource objectResource = object.getObject();
236                 if(graph.sync(new IsEnumeratedValue(objectResource))) {
237
238                         Resource type = graph.getSingleObject(objectResource, L0.PartOf);
239
240                         Map<String, Resource> enumMap = graph.syncRequest(new EnumerationMap(type));
241                         Resource newLiteral = enumMap.get(value);
242                         graph.deny(container, property, objectResource);
243                         graph.claim(container, property, newLiteral);
244
245                         return null;
246
247                 }
248
249                 Resource newType = Layer0Utils.getPossibleLiteralType(graph, variable);
250                 if(newType == null) {
251                         Type type = Layer0Utils.getSCLType(graph, variable);
252                         // This means that type is a wildcard e.g. "a"
253                         if(Types.canonical(type) instanceof TVar) {
254                                 newType = Layer0Utils.inferLiteralTypeFromString(graph, value.toString());
255                         } else {
256                                 throw new DatabaseException("Failed to find type for property " + NameUtils.getSafeName(graph, property));
257                         }
258                 }
259
260                 boolean correctType = graph.getPossibleType(objectResource, newType) != null;
261                 boolean asserted = object.isAsserted(container);
262                 if(asserted || !correctType) {
263
264                         if(correctType) {
265
266                                 Statement dt = graph.getPossibleStatement(objectResource, L0.HasDataType);
267                                 Datatype custom = dt.isAsserted(objectResource) ? null : (Datatype)graph.getValue(dt.getObject(), datatype_binging);
268
269                                 objectResource = graph.newResource();
270                                 graph.claim(objectResource, L0.InstanceOf, null, newType);
271                                 graph.claim(container, property, objectResource);
272                                 if(custom != null) {
273                                         // Only set HasValueType if the calculated new SCL type differs from the asserted value type
274                                         String newValueType = Layer0Utils.getSCLType(custom);
275                                         String currentValueType = graph.getPossibleRelatedValue(objectResource, L0.HasValueType, Bindings.STRING);
276                                         if (!newValueType.equals(currentValueType)) {
277                                                 graph.addLiteral(objectResource, L0.HasValueType, L0.HasValueType_Inverse, L0.String, newValueType, Bindings.STRING);
278                                         }
279                                         graph.addLiteral(objectResource, L0.HasDataType, L0.HasDataType_Inverse, L0.DataType, custom, datatype_binging);
280                                 }
281
282                         } else {
283
284                                 if(newType != null) {
285
286                                         if(!correctType && !asserted) // if not correct type and not asserted, remove the old value
287                                                 graph.deny(container, property, objectResource);
288
289                                         objectResource = graph.newResource();
290                                         graph.claim(objectResource, L0.InstanceOf, newType);
291                                         graph.claim(container, property, objectResource);
292
293                                 }
294
295                         }
296
297                 }
298
299                 Datatype datatype = variable.getDatatype(graph);
300                 Binding binding = (Binding)_binding;
301                 Layer0Utils.claimAdaptedValue(graph, objectResource, value, binding, datatype);
302
303                 return null;
304
305         }
306
307         @SCLValue(type = "ReadGraph -> a -> Resource")
308         public static Resource singleResourceTransformation(ReadGraph graph, Object input) throws DatabaseException {
309                 return WorkbenchSelectionUtils.getPossibleResource(graph, input);
310         }
311
312
313         @SCLValue(type = "ReadGraph -> a -> Variable")
314         public static Variable singleVariableTransformation(ReadGraph graph, Object input) throws DatabaseException {
315                 Variable single = WorkbenchSelectionUtils.getPossibleVariable(graph, input);
316                 if(single != null) return single;
317                 return ISelectionUtils.filterSingleSelection(input, Variable.class);
318         }
319
320         @SCLValue(type = "ReadGraph -> a -> Variable")
321         public static Variable singleResourceToVariableTransformation(ReadGraph graph, Object input) throws DatabaseException {
322                 Resource r = WorkbenchSelectionUtils.getPossibleResource(graph, input);
323                 if (r == null)
324                         return null;
325                 return Variables.getPossibleVariable(graph, r);
326         }
327
328         @SCLValue(type = "ReadGraph -> a -> SelectionInput")
329         public static SelectionInput standardSelectionInputTransformation(ReadGraph graph, Object input) throws DatabaseException {
330                 WorkbenchSelectionElement wse = WorkbenchSelectionUtils.getPossibleSelectionElement(input);
331                 if (wse == null)
332                         return null;
333                 return new StandardSelectionInput(wse);
334         }
335
336         @SCLValue(type = "ValueAccessor")
337         public static ValueAccessor displayUnitValueAccessor = new ValueAccessor() {
338
339                 @Override
340                 public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
341                         return Variables.getPossibleUnit(graph, context.getParent(graph));
342                 }
343
344                 @Override
345                 public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
346                         try {
347                                 Object value = Variables.getPossibleUnit(graph, context.getParent(graph));
348                                 if(value == null) return null;
349                                 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
350                                 return Bindings.adapt(value, srcBinding, binding);
351                         } catch (AdaptException e) {
352                                 throw new DatabaseException(e);
353                         } catch (BindingException e) {
354                                 throw new DatabaseException(e);
355                         }
356                 }
357
358                 @Override
359                 public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
360                         throw new UnsupportedOperationException();
361                 }
362
363                 @Override
364                 public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
365                         throw new UnsupportedOperationException();
366                 }
367
368                 @Override
369                 public Datatype getDatatype(ReadGraph graph, Variable context) throws DatabaseException {
370                         return org.simantics.db.layer0.function.All.getDatatypeFromValue(graph, context);
371                 }
372
373         };
374
375         @SCLValue(type = "ValueAccessor")
376         public static ValueAccessor displayPropertyValueAccessor = new ValueAccessor() {
377
378                 @Override
379                 public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
380                         return getValue(graph, context, Bindings.STRING);
381                 }
382
383                 @Override
384                 public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
385                         Layer0 L0 = Layer0.getInstance(graph);
386                         Variable property = context.getParent(graph);
387                         Resource predicate = property.getPossiblePredicateResource(graph);
388                         if(predicate == null) return property.getName(graph);
389                         String value = graph.getPossibleRelatedValue2(predicate, L0.HasLabel, Bindings.STRING);
390                         if(value == null)
391                             value = graph.getRelatedValue(predicate, L0.HasName, Bindings.STRING);
392                         try {
393                                 return Bindings.adapt(value, binding, Bindings.STRING);
394                         } catch (AdaptException e) {
395                                 throw new DatabaseException(e);
396                         }
397                 }
398
399                 @Override
400                 public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
401                         throw new UnsupportedOperationException();
402                 }
403
404                 @Override
405                 public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
406                         throw new UnsupportedOperationException();
407                 }
408
409                 @Override
410                 public Datatype getDatatype(ReadGraph graph, Variable context)
411                                 throws DatabaseException {
412                         return Datatypes.STRING;
413                 }
414
415         };      
416
417         @SCLValue(type = "ValueAccessor")
418         public static ValueAccessor displayValueValueAccessor = new ValueAccessor() {
419
420                 @Override
421                 public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
422                         return getValue(graph, context, Bindings.STRING);
423                 }
424
425                 public boolean isPrimitive(Datatype dt) {
426                         if(Datatypes.STRING.equals(dt)) return true;
427                         else return false;
428                 }
429
430                 private String possibleExpression(ReadGraph graph, Variable variable) throws DatabaseException {
431
432                         Layer0 L0 = Layer0.getInstance(graph);
433                         Resource object = variable.getPossibleRepresents(graph);
434                         if(object != null && graph.isInstanceOf(object, L0.SCLValue)) {
435                                 String expression = graph.getPossibleRelatedValue(object, L0.SCLValue_expression);
436                                 if (expression != null)
437                                         return "=" + expression;
438                         }
439                         return null;
440
441                 }
442
443                 @Override
444                 public Object getValue(ReadGraph graph, Variable context, Binding _binding) throws DatabaseException {
445
446                         Variable property = context.getParent(graph);
447
448                         String expression = possibleExpression(graph, property);
449                         if(expression != null) return expression;
450
451                         Object value = null;
452                         Resource formatter = property.getPossiblePropertyValue(graph, Variables.FORMATTER);
453                         if(formatter != null) {
454                                 
455                                 Formatter fmt = graph.adaptContextual(formatter, property, Variable.class, Formatter.class);
456                                 value = fmt.format(property.getValue(graph));
457                                 
458                         } else {
459
460                                 Variant variant = property.getVariantValue(graph);
461                                 value = variant.getValue();
462                                 
463                                 Binding binding = variant.getBinding();
464                                 if(binding != null) {
465                                         Datatype dt = binding.type();   
466                                         if(dt != null) {
467                                                 if(!isPrimitive(dt)) {
468                                                         try {
469                                                                 value = DataValuePrinter.writeValueSingleLine(binding, value);
470                                                         } catch (IOException e) {
471                                                                 e.printStackTrace();
472                                                         } catch (BindingException e) {
473                                                                 e.printStackTrace();
474                                                         }
475                                                 }
476                                         }
477                                 }
478
479                         }
480
481                         try {
482                                 return Bindings.adapt(value != null ? value.toString() : "null", _binding, Bindings.STRING);
483                         } catch (AdaptException e) {
484                                 throw new DatabaseException(e);
485                         }
486                 }
487
488                 @Override
489                 public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
490                         try {
491                                 Binding binding = Bindings.getBinding(value.getClass());
492                                 setValue(graph, context, value, binding);
493                         } catch (BindingConstructionException e) {
494                                 throw new DatabaseException(e);
495                         }
496                 }
497
498                 @Override
499                 public void setValue(WriteGraph graph, Variable context, Object _value, Binding _binding) throws DatabaseException {
500                         try {
501
502                                 if(!(_value instanceof String)) throw new DatabaseException("setValue for HasDisplayValue only accepts String (got " + _value.getClass().getSimpleName() + ")");
503
504                                 String text = (String)_value;
505                                 if(text.startsWith("=")) {
506                                         Variable property = context.getParent(graph);
507                                         Layer0Utils.setExpression(graph, property, text, ModelingResources.getInstance(graph).SCLValue);
508                                         return;
509                                 }
510
511                                 String parsedLabel = (String)_value;
512                                 Object value = parsedLabel;
513
514                                 Datatype type = context.getParent(graph).getPossibleDatatype(graph);
515                                 if (type != null) {
516
517                                         Binding binding = Bindings.getBinding(type);
518
519                                         if (binding instanceof StringBinding) {
520
521                                                 if (binding instanceof MutableStringBinding)
522                                                         value = new MutableString(parsedLabel);
523                                                 else
524                                                         value = parsedLabel;
525
526                                         } else {
527
528                                                 if (binding instanceof NumberBinding) {
529                                                         parsedLabel = parsedLabel.replace(",", ".");
530                                                 }
531
532                                                 value = binding.parseValue(parsedLabel, new DataValueRepository());
533                                         }
534
535                                         //System.out.println("VariableWrite " + ObjectUtils.toString(value));
536                                         context.getParent(graph).setValue(graph, value, binding);
537
538                                 } else {
539
540                                         context.getParent(graph).setValue(graph, value);
541
542                                 }
543
544
545                                 // Add a comment to metadata.
546                                 CommentMetadata cm = graph.getMetadata(CommentMetadata.class);
547                                 graph.addMetadata(cm.add("Set value " + ObjectUtils.toString(value)));
548
549                         } catch (DataTypeSyntaxError e) {
550                                 throw new DatabaseException(e);
551                         } catch (BindingException e) {
552                                 throw new DatabaseException(e);
553                         }
554                 }
555
556                 @Override
557                 public Datatype getDatatype(ReadGraph graph, Variable context)
558                                 throws DatabaseException {
559                         return Datatypes.STRING;
560                 }
561
562         };              
563 }