bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/VariableModifier.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.browsing.ui.graph.impl;
  13
  14 import org.simantics.browsing.ui.content.Labeler.Modifier;
  15 import org.simantics.databoard.Bindings;
  16 import org.simantics.databoard.Datatypes;
  17 import org.simantics.databoard.binding.Binding;
  18 import org.simantics.databoard.binding.NumberBinding;
  19 import org.simantics.databoard.binding.StringBinding;
  20 import org.simantics.databoard.binding.error.BindingException;
  21 import org.simantics.databoard.binding.mutable.MutableStringBinding;
  22 import org.simantics.databoard.parser.repository.DataTypeSyntaxError;
  23 import org.simantics.databoard.parser.repository.DataValueRepository;
  24 import org.simantics.databoard.primitives.MutableString;
  25 import org.simantics.databoard.type.Datatype;
  26 import org.simantics.databoard.type.NumberType;
  27 import org.simantics.databoard.units.IUnitConverter;
  28 import org.simantics.databoard.util.Range;
  29 import org.simantics.db.ReadGraph;
  30 import org.simantics.db.RequestProcessor;
  31 import org.simantics.db.Resource;
  32 import org.simantics.db.Session;
  33 import org.simantics.db.UndoContext;
  34 import org.simantics.db.WriteGraph;
  35 import org.simantics.db.common.request.ReadRequest;
  36 import org.simantics.db.common.request.WriteRequest;
  37 import org.simantics.db.exception.DatabaseException;
  38 import org.simantics.db.layer0.util.PrimitiveValueParser;
  39 import org.simantics.db.layer0.variable.InputValidator;
  40 import org.simantics.db.layer0.variable.InputValidatorFactory;
  41 import org.simantics.db.layer0.variable.Variable;
  42 import org.simantics.db.layer0.variable.VariableWrite;
  43 import org.simantics.db.layer0.variable.Variables;
  44 import org.simantics.scl.runtime.function.Function1;
  45 import org.simantics.utils.format.FormattingUtils;
  46 import org.simantics.utils.ui.ErrorLogger;
  47
  48 /**
  49  * @author Tuukka Lehtonen
  50  */
  51 public class VariableModifier implements Modifier {
  52
  53     final protected Session     session;
  54     final protected UndoContext undoContext;
  55     final protected Variable    variable;
  56     final protected String      targetUnit;
  57
  58     private String              initialValue;
  59     protected Throwable         modifierFailed;
  60     private Datatype            datatype;
  61     protected Binding           binding;
  62     protected InputValidator    variableInputValidator;
  63
  64     public VariableModifier(RequestProcessor processor, Variable variable) {
  65         this(processor, variable, null);
  66     }
  67
  68     public VariableModifier(RequestProcessor processor, Variable variable, String targetUnit) {
  69         this.variable = variable;
  70         this.session = processor.getSession();
  71         this.undoContext = null;
  72         this.targetUnit = targetUnit;
  73
  74         initializeModifier(processor);
  75     }
  76
  77     public VariableModifier(RequestProcessor processor, UndoContext undoContext, Variable variable, String targetUnit) {
  78         this.variable = variable;
  79         this.undoContext = undoContext;
  80         this.session = processor.getSession();
  81         this.targetUnit = targetUnit;
  82
  83         initializeModifier(processor);
  84     }
  85
  86     protected void initializeModifier(RequestProcessor processor) {
  87         try {
  88             processor.syncRequest(new ReadRequest() {
  89                 @Override
  90                 public void run(ReadGraph graph) throws DatabaseException {
  91                         String expression = variable.getPossiblePropertyValue(graph, Variables.EXPRESSION);
  92                         if(expression == null) {
  93                             datatype = variable.getPossibleDatatype(graph);
  94                             if (datatype == null) {
  95                                 // Deprecated.
  96                                 // This is here for some backwards compatibility.
  97                                 datatype = variable.getInterface(graph, Datatype.class);
  98                                 if (datatype == null)
  99                                     throw new org.simantics.db.exception.BindingException("no datatype for variable " + variable, null);
 100                             }
 101                             initialValue = getInitialValue(graph, datatype);
 102                             binding = Bindings.getBinding(datatype);
 103                             initializeValidator(graph, variable);
 104                         }
 105                         else {
 106                                 initialValue = "= " + expression;
 107                                 binding = Bindings.STRING;
 108                                 datatype = Datatypes.STRING;
 109                         }
 110                 }
 111             });
 112         } catch (DatabaseException e) {
 113             ErrorLogger.defaultLogError("Modifier initialization failed, see exception for details.", e);
 114             modifierFailed = e;
 115         }
 116     }
 117
 118     protected void initializeValidator(ReadGraph graph, Variable var) throws DatabaseException {
 119         //System.out.println(var.getURI(graph));
 120
 121         Resource resource = var.getPossibleRepresents(graph);
 122 //        if (resource != null)
 123 //            System.out.println("represents: " + graph.getPossibleURI(resource));
 124
 125         Resource pr = variable.getPossiblePredicateResource(graph);
 126
 127 //        Variable predicate = variable.getPossiblePropertyValue(graph, Variables.PREDICATE);
 128 //        if (predicate != null) {
 129 //            Resource pr = predicate.getPropertyValue(graph, Variables.REPRESENTS);
 130             if (pr != null)
 131                 variableInputValidator = tryInputValidatorFactory(graph, var, resource, pr);
 132 //        }
 133
 134         if (variableInputValidator == null) {
 135             final Function1<String, String> validator = variable.getPossiblePropertyValue(graph, Variables.INPUT_VALIDATOR);
 136             if (validator != null)
 137                 variableInputValidator = new InputValidator() {
 138
 139                     @Override
 140                     public String isValid(Object newValue) {
 141                         return validator.apply((String)newValue);
 142                     }
 143                 };
 144         }
 145
 146         if (variableInputValidator == null) {
 147             Variable parent = variable.getParent(graph);
 148             if (parent != null) {
 149                 Resource parentResource = parent.getPossibleRepresents(graph);
 150                 if (parentResource != null)
 151                     variableInputValidator = tryInputValidatorFactory(graph, var, resource, parentResource);
 152             }
 153         }
 154
 155         if (variableInputValidator == null)
 156             variableInputValidator = var.getInterface(graph, InputValidator.class);
 157
 158     }
 159
 160     private InputValidator tryInputValidatorFactory(ReadGraph graph, Variable var, Resource varRepresents, Resource r) throws DatabaseException {
 161         //System.out.println("tryInputValidatorFactory(" + var.getURI(graph) + ", " + NameUtils.getSafeName(graph, varRepresents) + ", " + NameUtils.getSafeName(graph, r) + ")");
 162         InputValidatorFactory validatorFactory = graph.getPossibleAdapter(r, InputValidatorFactory.class);
 163         if (validatorFactory == null)
 164             return null;
 165         //System.out.println("got validator factory: " + validatorFactory);
 166         return validatorFactory.create(graph, var);
 167     }
 168
 169     protected void doModify(final String label) {
 170         if(label.startsWith("=")) {
 171                 session.asyncRequest(new WriteRequest() {
 172                                 @Override
 173                                 public void perform(WriteGraph graph) throws DatabaseException {
 174                                         variable.setPropertyValue(graph, Variables.EXPRESSION,
 175                                                         label.substring(1).trim());
 176                                 }
 177                         });
 178         }
 179         else {
 180                 if(initialValue.startsWith("="))
 181                                 try {
 182                                         session.syncRequest(new WriteRequest() {
 183                                                 @Override
 184                                                 public void perform(WriteGraph graph) throws DatabaseException {
 185                                                         variable.setPropertyValue(graph, Variables.EXPRESSION, null);
 186                                                 }
 187                                         });
 188                                 } catch (DatabaseException e) {
 189                                         e.printStackTrace();
 190                                 }
 191                 session.asyncRequest(new VariableWrite(variable, label, null, targetUnit), parameter -> {
 192                     if (parameter != null)
 193                         ErrorLogger.defaultLogError(parameter);
 194                     else
 195                         modifySuccessful();
 196                 });
 197         }
 198     }
 199
 200     protected void modifySuccessful() {
 201         }
 202
 203         protected String getInitialValue(ReadGraph graph, Datatype dataType) throws DatabaseException {
 204         // TODO: more generic support through DataValuePrinter
 205         Object value = variable.getPossibleValue(graph);
 206         if(value == null) return "";
 207         String unit = Variables.getPossibleUnit(graph, variable);
 208         //String unit = variable.getPossiblePropertyValue(graph, Variables.UNIT);
 209         if(value instanceof Double && unit != null && targetUnit != null) {
 210             IUnitConverter converter = VariableWrite.converter(unit, targetUnit);
 211             value = converter.convert((Double)value);
 212         }
 213         return FormattingUtils.US.engineeringFormat(value);
 214     }
 215
 216     @Override
 217     public String getValue() {
 218         return initialValue;
 219     }
 220
 221     @Override
 222     public String isValid(String label) {
 223         if (label.startsWith("="))
 224             return null;
 225
 226         if (modifierFailed != null)
 227             return "Could not resolve validator for this value, modification denied. Reason: " + modifierFailed.getMessage();
 228
 229         if (variableInputValidator != null)
 230             return variableInputValidator.isValid(label);
 231
 232         try {
 233             if (binding instanceof StringBinding) {
 234                 // Use the binding to validate strings since they might have
 235                 // mime-types and/or patterns attached.
 236                 if (binding instanceof MutableStringBinding) {
 237                     binding.assertInstaceIsValid(new MutableString(label));
 238                 } else {
 239                     binding.assertInstaceIsValid(label);
 240                 }
 241             } else {
 242                 if (binding instanceof NumberBinding) {
 243                     // Numbers are always parsed in US locale, although both ',' and
 244                     // '.' are accepted as decimal separators.
 245                     label = label.replace(",", ".");
 246                     //Object value = binding.parseValue(label, new DataValueRepository());
 247                     Object value = PrimitiveValueParser.parse(label, datatype);
 248                     NumberType numberType = (NumberType) datatype;
 249                     Range range = numberType.getRange();
 250                     if (range != null && !range.contains((Number) value))
 251                         return "Value is not in range " + range;
 252                 } else {
 253                     binding.parseValue(label, new DataValueRepository());
 254                 }
 255             }
 256             return null;
 257         } catch (IllegalArgumentException e) {
 258             // Parsing failed.
 259             return e.getLocalizedMessage();
 260         } catch (DataTypeSyntaxError e) {
 261             // Failed to parse label with binding
 262             return e.getLocalizedMessage();
 263         } catch (BindingException e) {
 264             return e.getLocalizedMessage();
 265         }
 266     }
 267
 268     @Override
 269     public final void modify(String label) {
 270         if (modifierFailed != null)
 271             // Should never end up here, isValid should prevent it.
 272             throw new Error("modifier failed: " + modifierFailed.getMessage());
 273         doModify(label);
 274     }
 275
 276 };