bundles/org.simantics.modeling/src/org/simantics/modeling/subscription/SubscriptionItemLabel.java

   1 package org.simantics.modeling.subscription;
   2
   3 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
   4 import org.eclipse.core.runtime.preferences.InstanceScope;
   5 import org.simantics.databoard.Bindings;
   6 import org.simantics.databoard.Databoard;
   7 import org.simantics.databoard.accessor.reference.ChildReference;
   8 import org.simantics.databoard.accessor.reference.IndexReference;
   9 import org.simantics.databoard.binding.Binding;
  10 import org.simantics.databoard.util.URIStringUtils;
  11 import org.simantics.db.ReadGraph;
  12 import org.simantics.db.Resource;
  13 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  14 import org.simantics.db.common.request.PossibleIndexRoot;
  15 import org.simantics.db.exception.DatabaseException;
  16 import org.simantics.db.layer0.exception.PendingVariableException;
  17 import org.simantics.db.layer0.request.PossibleVariableValue;
  18 import org.simantics.db.layer0.variable.RVI;
  19 import org.simantics.db.layer0.variable.Variable;
  20 import org.simantics.layer0.Layer0;
  21 import org.simantics.modeling.ModelingResources;
  22 import org.simantics.utils.datastructures.Pair;
  23 import org.simantics.utils.format.FormattingUtils;
  24 import org.simantics.utils.format.ValueFormat;
  25
  26 public class SubscriptionItemLabel {
  27
  28     private static final String NO_VARIABLE_ID = "<no variable id>";
  29
  30     public static String resolveLabel(ReadGraph graph, Resource item, boolean synchronous) throws DatabaseException {
  31         IEclipsePreferences chartPreferenceNode = InstanceScope.INSTANCE.getNode( "org.simantics.charts" );
  32         String s = chartPreferenceNode.get("chart.valueformat", ValueFormat.Default.name());
  33         ValueFormat valueFormat = ValueFormat.valueOf( s );
  34         return resolveLabel(graph, item, valueFormat, synchronous);
  35     }
  36
  37     public static String resolveLabel(ReadGraph graph, Resource item, ValueFormat valueFormat, boolean synchronous) throws DatabaseException {
  38         return resolveLabel(graph, item, valueFormat, synchronous, true, true);
  39     }
  40
  41     public static String resolveLabel(ReadGraph graph, Resource item, ValueFormat valueFormat, boolean synchronous, boolean tryLabel, boolean showValue) throws DatabaseException {
  42
  43         Layer0 L0 = Layer0.getInstance(graph);
  44         ModelingResources MOD = ModelingResources.getInstance(graph);
  45
  46         String label = tryLabel ? graph.<String>getPossibleRelatedValue(item, L0.HasLabel, Bindings.STRING) : null;
  47         boolean labelDefined = isNonempty(label);
  48         if (!showValue && labelDefined)
  49             return label;
  50
  51         // Create label from rvi
  52         Binding rviBinding = graph.getService(Databoard.class).getBindingUnchecked( RVI.class );
  53         RVI rvi = graph.getPossibleRelatedValue(item, MOD.Subscription_Item_VariableId, rviBinding);
  54         if (rvi == null)
  55             return NO_VARIABLE_ID;
  56
  57         Resource model = graph.syncRequest(new PossibleIndexRoot(item));
  58         if (model != null) {
  59             ModelContexts contexts = graph.syncRequest(new ModelContextsRequest(model), TransientCacheAsyncListener.<ModelContexts>instance());
  60             Variable configurationContext = contexts.getConfigurationContext();
  61             Variable experimentContext = contexts.getExperimentContext();
  62
  63             if (configurationContext != null) {
  64                 // Resolve variable and take note of the resolution context
  65                 Variable variable = null;
  66                 Variable resolutionContext = experimentContext;
  67                 String resolutionContextURI = contexts.getExperimentContextURI();
  68                 if (showValue && experimentContext != null)
  69                     variable = rvi.resolvePossible(graph, experimentContext);
  70                 if (variable == null) {
  71                     resolutionContext = configurationContext;
  72                     resolutionContextURI = contexts.getConfigurationContextURI();
  73                     variable = rvi.resolvePossible(graph, configurationContext);
  74                 }
  75
  76                 if (variable != null) {
  77                     if (!labelDefined) {
  78                         label = relativeURI(graph, variable, resolutionContextURI);
  79                         if (label == null)
  80                             label = rvi.toPossibleString(graph, configurationContext);
  81                         if (label != null) {
  82                             label = removeVariablePrefixPath(label);
  83                             label = URIStringUtils.unescape(label);
  84                         }
  85                     }
  86
  87                     if (showValue && resolutionContext == experimentContext) {
  88                         StringBuilder sb = new StringBuilder(label);
  89
  90                         Double gain = graph.getPossibleRelatedValue(item, MOD.Subscription_Item_Gain, Bindings.DOUBLE);
  91                         Double bias = graph.getPossibleRelatedValue(item, MOD.Subscription_Item_Bias, Bindings.DOUBLE);
  92                         String unit = graph.getPossibleRelatedValue(item, MOD.Subscription_Item_Unit, Bindings.STRING);
  93
  94                         boolean oldSync = graph.setSynchronous(synchronous);
  95                         try {
  96                             Object value = graph.syncRequest( new PossibleVariableValue<Object>(variable) );
  97                             sb = formatValue(value, gain, bias, unit, valueFormat, sb);
  98                         } catch (PendingVariableException e) {
  99                             sb.append(" (<pending>)");
 100                         } finally {
 101                             graph.setSynchronous(oldSync);
 102                         }
 103
 104                         label = sb.toString();
 105                     }
 106                 }
 107             }
 108         }
 109
 110         return label != null ? label : NO_VARIABLE_ID;
 111     }
 112
 113     private static StringBuilder formatValue(Object value, Double gain, Double bias, String unit, ValueFormat valueFormat, StringBuilder sb) {
 114         if (value instanceof Number) {
 115             double d = ((Number) value).doubleValue();
 116             double ad = d;
 117             if (gain != null)
 118                 ad *= gain;
 119             if (bias != null)
 120                 ad += bias;
 121             sb.append(" (").append(valueFormat.format.format(ad));
 122         } else {
 123             sb.append(" (").append(FormattingUtils.engineeringFormat(value));
 124         }
 125         if (unit != null && !unit.isEmpty()) {
 126             sb.append(' ').append(unit);
 127         }
 128         return sb.append(')');
 129     }
 130
 131     public static String removeVariablePrefixPath(String rvi) {
 132         // Apros-specific logics:
 133         //   1. remove path prefix
 134         //   2. change IndexReferences (i-N) into "(N+1)" Apros-style indexing
 135         int propIndex = rvi.indexOf('#');
 136         if (propIndex == -1)
 137             return rvi;
 138         int prevSlash = rvi.lastIndexOf('/', propIndex);
 139         if (prevSlash == -1)
 140             return rvi;
 141         Pair<String, Integer> attrKey = attributeKey(rvi, propIndex + 1);
 142         return rvi.substring(prevSlash + 1, propIndex + 1) + attrKey.first
 143                 + (attrKey.second != null ? "(" + (attrKey.second + 1) + ")" : "");
 144     }
 145
 146     private static Pair<String, Integer> attributeKey(String key, int start) {
 147         int iy = key.lastIndexOf('/');
 148         boolean isIndexed = iy >= start;
 149         if (isIndexed) {
 150             ChildReference child = ChildReference.parsePath(key.substring(iy + 1));
 151             if (child instanceof IndexReference)
 152                 return Pair.make(key.substring(start, iy), ((IndexReference) child).getIndex());
 153         }
 154         return Pair.make(key.substring(start), null);
 155     }
 156
 157     private static boolean isNonempty(String label) {
 158         return label != null && !label.trim().isEmpty();
 159     }
 160
 161     private static String relativeURI(ReadGraph graph, Variable variable, String contextURI) throws DatabaseException {
 162         return relativeURI(variable.getURI(graph), contextURI);
 163     }
 164
 165     private static String relativeURI(String fullURI, String contextURI) {
 166         return fullURI.substring(contextURI.length());
 167     }
 168
 169 }