]> gerrit.simantics Code Review - simantics/platform.git/blob
3938e478b923d768220952d44301eedb449388f1
[simantics/platform.git] /
1 package org.simantics.spreadsheet.graph;
2
3 import java.io.File;
4 import java.io.FileNotFoundException;
5 import java.io.FileOutputStream;
6 import java.io.IOException;
7 import java.io.ObjectOutputStream;
8 import java.util.ArrayList;
9 import java.util.Collection;
10 import java.util.HashMap;
11 import java.util.Iterator;
12 import java.util.List;
13 import java.util.Map;
14
15 import javax.xml.soap.Node;
16
17 import org.simantics.Simantics;
18 import org.simantics.databoard.Bindings;
19 import org.simantics.databoard.binding.mutable.Variant;
20 import org.simantics.databoard.util.binary.RandomAccessBinary;
21 import org.simantics.datatypes.DatatypeResource;
22 import org.simantics.datatypes.literal.Font;
23 import org.simantics.datatypes.literal.RGB;
24 import org.simantics.datatypes.utils.BTree;
25 import org.simantics.db.ReadGraph;
26 import org.simantics.db.Resource;
27 import org.simantics.db.WriteGraph;
28 import org.simantics.db.common.request.BinaryRead;
29 import org.simantics.db.common.request.ObjectsWithType;
30 import org.simantics.db.common.request.UnaryRead;
31 import org.simantics.db.common.request.WriteRequest;
32 import org.simantics.db.common.utils.LiteralFileUtil;
33 import org.simantics.db.exception.DatabaseException;
34 import org.simantics.db.exception.ServiceException;
35 import org.simantics.db.layer0.util.Layer0Utils;
36 import org.simantics.db.layer0.variable.StandardGraphChildVariable;
37 import org.simantics.db.layer0.variable.Variable;
38 import org.simantics.db.layer0.variable.VariableNode;
39 import org.simantics.db.layer0.variable.Variables;
40 import org.simantics.db.procedure.Listener;
41 import org.simantics.db.service.ClusteringSupport;
42 import org.simantics.layer0.Layer0;
43 import org.simantics.scl.runtime.SCLContext;
44 import org.simantics.scl.runtime.function.Function;
45 import org.simantics.scl.runtime.function.Function1;
46 import org.simantics.scl.runtime.tuple.Tuple;
47 import org.simantics.scl.runtime.tuple.Tuple0;
48 import org.simantics.scl.runtime.tuple.Tuple2;
49 import org.simantics.simulator.toolkit.StandardRealm;
50 import org.simantics.spreadsheet.CellEditor;
51 import org.simantics.spreadsheet.ExternalRef;
52 import org.simantics.spreadsheet.OperationMode;
53 import org.simantics.spreadsheet.Range;
54 import org.simantics.spreadsheet.Spreadsheets;
55 import org.simantics.spreadsheet.Transaction;
56 import org.simantics.spreadsheet.graph.synchronization.SpreadsheetSynchronizationEventHandler;
57 import org.simantics.spreadsheet.resource.SpreadsheetResource;
58 import org.simantics.spreadsheet.solver.SheetNode;
59 import org.simantics.spreadsheet.solver.SpreadsheetBook;
60 import org.simantics.spreadsheet.solver.SpreadsheetCell;
61 import org.simantics.spreadsheet.solver.SpreadsheetEngine;
62 import org.simantics.spreadsheet.solver.SpreadsheetLine;
63 import org.simantics.spreadsheet.solver.SpreadsheetStyle;
64 import org.simantics.spreadsheet.util.SpreadsheetUtils;
65 import org.simantics.structural.synchronization.client.Synchronizer;
66 import org.slf4j.Logger;
67 import org.slf4j.LoggerFactory;
68
69 import gnu.trove.iterator.TObjectIntIterator;
70 import gnu.trove.map.hash.TObjectIntHashMap;
71
72 public class SpreadsheetGraphUtils {
73
74     private static final Logger LOGGER = LoggerFactory.getLogger(SpreadsheetGraphUtils.class);
75
76     public static File extractInitialCondition(ReadGraph graph, Resource ic) throws DatabaseException, IOException {
77
78         SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
79
80         File temp = Simantics.getTempfile("excel","ic");
81
82         LiteralFileUtil.copyRandomAccessBinaryToFile(graph, ic, SR.InitialCondition_bytes, temp);
83         if (temp.length() == 0)
84             throw new FileNotFoundException("Snapshot file does not exist.\nThis seems to be a database bug that manifests as total loss of state file data.\nThis error prevents the program from crashing.");
85
86         return temp;
87         
88     }
89         
90     public static RandomAccessBinary getOrCreateRandomAccessBinary(WriteGraph graph, Resource initialCondition) throws DatabaseException, IOException {
91
92         SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
93         
94         // We put snapshot literals in their own clusters for now just to be safe
95         Resource literal = graph.getPossibleObject(initialCondition, SR.InitialCondition_bytes);
96         if (literal != null) {
97             RandomAccessBinary rab = graph.getRandomAccessBinary(literal);
98             rab.position(0);
99             rab.removeBytes(rab.length(), RandomAccessBinary.ByteSide.Right);
100             return rab;
101         } else {
102             Layer0 L0 = Layer0.getInstance(graph);
103             ClusteringSupport cs = graph.getService(ClusteringSupport.class);
104             literal = graph.newResource(cs.createCluster());
105             graph.claim(literal, L0.InstanceOf, null, L0.ByteArray);
106             graph.claim(initialCondition, SR.InitialCondition_bytes, SR.InitialCondition_bytes_Inverse, literal);
107             return graph.createRandomAccessBinary(literal, Bindings.BYTE_ARRAY.type(), null);
108         }
109     }
110
111     public static Resource saveInitialCondition(WriteGraph graph, Variable run, Resource container, String name) throws DatabaseException {
112
113                 String sessionName = run.getParent(graph).getURI(graph);
114
115                 Resource bookResource = run.getRepresents(graph);
116                 
117         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
118         SpreadsheetBook book = realm.getEngine();
119
120         try {
121         
122                 File temp = Simantics.getTempfile("excel", "ic");
123                 System.err.println("Saving initial condition to " + temp.getAbsolutePath());
124                 
125                         FileOutputStream fileOut = new FileOutputStream(temp);
126                         ObjectOutputStream out = new ObjectOutputStream(fileOut);
127                         out.writeObject(book);
128                         out.close();
129                         fileOut.close();
130                         
131                         Layer0 L0 = Layer0.getInstance(graph);
132                 SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
133                         Resource ic = graph.newResource();
134                         graph.claim(ic, L0.InstanceOf, SR.InitialCondition);
135                         graph.addLiteral(ic, L0.HasName, L0.NameOf, L0.String, name, Bindings.STRING);
136                 
137                 RandomAccessBinary rab = getOrCreateRandomAccessBinary(graph, ic);
138                 LiteralFileUtil.copyRandomAccessBinaryFromFile(temp, rab);
139                 
140                         graph.claim(container, L0.ConsistsOf, L0.PartOf, ic);
141                         
142                         graph.deny(bookResource, SR.HasInitialCondition);
143                         graph.claim(bookResource, SR.HasInitialCondition, ic);
144                         graph.claim(ic, SR.InitialCondition_ConditionOf, bookResource);
145                         
146                         setDefaultInitialConditionForBook(graph, bookResource, ic);
147
148                 return ic;
149                 
150         } catch (IOException e) {
151                 
152                 throw new DatabaseException(e);
153                 
154         }
155     }
156     
157     public static void setDefaultInitialConditionForBook(WriteGraph graph, Resource book, Resource ic) throws ServiceException {
158         SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
159         graph.deny(book, SR.Book_HasDefaultInitialCondition);
160         graph.claim(ic, SR.InitialCondition_DefaultConditionOf, book);
161     }
162
163     public static void evaluateAll(ReadGraph graph, Variable run) throws DatabaseException {
164
165                 String sessionName = run.getParent(graph).getURI(graph);
166         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
167         SpreadsheetBook book = realm.getEngine();
168         book.accept(new EvaluateAll(book));
169         
170     }
171
172     public static void invalidateAll(ReadGraph graph, Variable run) throws DatabaseException {
173
174                 String sessionName = run.getParent(graph).getURI(graph);
175         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
176         SpreadsheetBook book = realm.getEngine();
177         book.accept(new InvalidateAll());
178         realm.getNodeManager().refreshVariables();
179         
180     }
181     
182     public static boolean fullSynchronization(ReadGraph graph, Variable run) throws DatabaseException {
183         return partialSynchronization(graph, run, null);
184     }
185
186     public static boolean partialSynchronization(ReadGraph graph, Variable run, TObjectIntHashMap<Variable> changeFlags) throws DatabaseException {
187
188         Synchronizer synchronizer = new Synchronizer(graph);
189                 String sessionName = run.getParent(graph).getURI(graph);
190                 
191         Resource bookResource = run.getRepresents(graph);
192         Variable configuration = Variables.getVariable(graph, bookResource);
193         
194         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
195         SpreadsheetBook book = realm.getEngine();
196                         
197         SpreadsheetSynchronizationEventHandler handler = new SpreadsheetSynchronizationEventHandler(graph, book);
198         
199         if (changeFlags == null) {
200             synchronizer.fullSynchronization(configuration, handler);
201         } else {
202             
203             TObjectIntIterator<Variable> iter = changeFlags.iterator();
204             iter.advance();
205             Variable row = iter.key();
206             
207             Variable rowParent = row.getParent(graph);
208             while (!rowParent.equals(configuration)) {
209                 changeFlags.put(rowParent, 1);
210                 rowParent = rowParent.getParent(graph);
211             }
212             
213             changeFlags.put(configuration, 1);
214             
215             synchronizer.partialSynchronization(configuration, handler, changeFlags);
216         }
217         
218         realm.getNodeManager().fireNodeListeners();
219         return handler.getDidChanges();
220         
221     }
222
223     public static Variable findCell(ReadGraph graph, Variable run, String reference) throws DatabaseException {
224
225         int pos = reference.indexOf("!");
226         String sheetName = reference.substring(0, pos);
227         String cellName = reference.substring(pos+1);
228
229                 String sessionName = run.getParent(graph).getURI(graph);
230         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
231         SpreadsheetBook book = realm.getEngine();
232         SpreadsheetEngine engine = book.getEngine(sheetName);
233         if(engine == null) return null;
234         
235         Range r = Spreadsheets.decodeCellAbsolute(cellName);
236         SpreadsheetLine line = engine.getLine(r.startRow);
237         if(line == null) return null;
238         
239         String path = line.getPath();
240         if(path == null) return null;
241         
242         Variable lineVariable = run.browse(graph, path);
243         if(lineVariable==null) return null;
244         
245         return lineVariable.getChild(graph, cellName);
246         
247     }
248
249     public static void forRows(ReadGraph graph, Variable run, String sheetName, int min, int max, Function1<Variable, Tuple> fn) throws DatabaseException {
250
251         String sessionName = run.getParent(graph).getURI(graph);
252         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
253         SpreadsheetBook book = realm.getEngine();
254         SpreadsheetEngine engine = book.getEngine(sheetName);
255         if(engine == null) return;
256         
257         engine.forLines(line -> {
258
259             String path = line.getPath();
260             if(path == null) return;
261
262             try {
263                 Variable lineVariable = run.browse(graph, path);
264                 if(lineVariable != null)
265                     fn.apply(lineVariable);
266             } catch (DatabaseException e) {
267                 // This is not reported here
268             }
269
270         } , min, max);
271         
272     }
273     
274     public static List<Variable> possibleConfigurationCellVariables(ReadGraph graph, Variable sheet, Range range) throws DatabaseException {
275         List<Variable> rowVariables = possibleConfigurationLineVariables(graph, sheet, range);
276         List<Variable> result = new ArrayList<>();
277         for (Variable variable : rowVariables) {
278             Collection<Variable> children = variable.getChildren(graph);
279             for (Variable child : children) {
280                 if (variableInRange(graph, child, range)) {
281                     result.add(child);
282                 }
283             }
284         }
285         return result;
286     }
287     
288     public static Map<Integer, Resource> possibleConfigurationLineResources(ReadGraph graph, Variable sheet, Range range) throws DatabaseException {
289         Variable lines = sheet.getPossibleChild(graph, "Lines");
290         if (lines == null)
291             throw new DatabaseException("Invalid input variable " + sheet.getURI(graph));
292         Resource linesR = lines.getRepresents(graph);
293         BTree bt = new BTree(graph, linesR);
294         List<Tuple2> tuples = bt.searchRangeBTree(graph, Variant.ofInstance(range.startRow), Variant.ofInstance(range.endRow));
295         Map<Integer, Resource> result = new HashMap<>(tuples.size());
296         for (Tuple2 tuple : tuples) {
297             Integer lineNumber = (Integer)((Variant)tuple.c0).getValue();
298             Resource resource = (Resource)tuple.c1;
299             result.put(lineNumber, resource);
300         }
301         return result; 
302     }
303     
304     public static List<Variable> possibleConfigurationLineVariables(ReadGraph graph, Variable sheet, Range range) throws DatabaseException {
305         Map<Integer, Resource> rows = possibleConfigurationLineResources(graph, sheet, range);
306         List<Variable> result = new ArrayList<>(rows.size());
307         for (Resource row: rows.values()) {
308             Variable lineVar = Variables.getPossibleVariable(graph, row);
309             if (lineVar != null)
310                 result.add(lineVar);
311         }
312         return result;
313     }
314     
315     public static List<Variable> possibleRunLineVariables(ReadGraph graph, Variable sheetRun, Range range) throws DatabaseException {
316         
317         Variable run = sheetRun.getParent(graph);
318         
319         String sheetName = sheetRun.getName(graph);
320         String sessionName = run.getParent(graph).getURI(graph);
321         
322         StandardRealm<SheetNode, SpreadsheetBook> realm = SpreadsheetSessionManager.getInstance().getOrCreateRealm(graph, sessionName);
323         SpreadsheetBook book = realm.getEngine();
324         
325         SpreadsheetEngine engine = book.getEngine(sheetName);
326         if(engine == null) return null;
327         
328         List<Variable> result = new ArrayList<>();
329         
330         int end = range.endRow < engine.lines.getMaxRow() ? range.endRow : engine.lines.getMaxRow();
331         for (int i = range.startRow; i <= end; i++) {
332                 SpreadsheetLine line = engine.getLine(i);
333                 if(line == null)
334                         continue;
335                 
336                 String path = line.getPath();
337                 path = line.getPath();
338                 if(path == null)
339                         continue;
340                 
341                 Variable lineVariable = run.browse(graph, path);
342                 if(lineVariable==null)
343                         continue;
344                 result.add(lineVariable);
345         }
346     
347         return result;
348     }
349     
350     public static List<Variable> possibleRunCellVariables(ReadGraph graph, Variable sheetRun, Range range) throws DatabaseException {
351         List<Variable> runLineVariable = possibleRunLineVariables(graph, sheetRun, range);
352         List<Variable> result = new ArrayList<>();
353         for (Variable variable : runLineVariable) {
354 //              System.out.println("line: " + variable.getURI(graph));
355             for (Variable child : variable.getChildren(graph)) {
356 //              System.out.print("cell : " + child.getURI(graph));
357                 if (variableInRange(graph, child, range)) {
358                     result.add(child);
359                 }
360             }
361         }
362         return result;
363     }
364     
365     private static boolean variableInRange(ReadGraph graph, Variable child, Range range) throws DatabaseException {
366         String name = child.getName(graph);
367         Range childRange = Spreadsheets.decodeCellAbsolute(name);
368 //        System.out.print(" and range " + childRange);
369         if (childRange != null && range.contains(childRange)) {
370 //              System.out.println(" => range.contains(childRange) = true");
371             return true;
372         }
373 //        System.out.println();
374         return false;
375     }
376     
377     public static Map<Integer, Resource> createConfigurationLineResources(WriteGraph graph, Variable sheet, Range range) throws DatabaseException {
378         Layer0 L0 = Layer0.getInstance(graph);
379         SpreadsheetResource SHEET = SpreadsheetResource.getInstance(graph);
380         
381         Variable lines = sheet.getPossibleChild(graph, "Lines");
382         if (lines == null)
383             throw new DatabaseException("Invalid input variable " + sheet.getURI(graph));
384         Resource linesR = lines.getRepresents(graph);
385         BTree bt = new BTree(graph, linesR);
386         
387         Map<Integer, Resource> result = new HashMap<>();
388         for (int lineNumber = range.startRow; lineNumber <= range.endRow; lineNumber++) {
389             Resource line = graph.newResource();
390             graph.claim(line, L0.InstanceOf, null, SHEET.Line);
391             graph.claimLiteral(line, L0.HasName, L0.NameOf, L0.String, "Row" + lineNumber, Bindings.STRING);
392             bt.insertBTree(graph, Variant.ofInstance(lineNumber), line);
393             result.put(lineNumber, line);
394         }
395         return result;
396     }
397
398     public static List<Variable> getOrCreateConfigurationCellVariables(WriteGraph graph, Variable sheet, Range range) throws DatabaseException {
399         
400         List<Variable> rows = possibleConfigurationLineVariables(graph, sheet, range);
401         if (rows.isEmpty()) {
402             createConfigurationLineResources(graph, sheet, range);
403             rows = possibleConfigurationLineVariables(graph, sheet, range);
404         }
405         
406         List<Variable> cells = possibleConfigurationCellVariables(graph, sheet, range);
407         if (cells.isEmpty()) {
408             Iterator<Variable> rowIterator = rows.iterator();
409             for (int rowNumber = range.startRow; rowNumber <= range.endRow; rowNumber++) {
410                 Variable row = rowIterator.next();
411                 for (int colNumber = range.startColumn; colNumber <= range.endColumn; colNumber++) {
412                     String location = Spreadsheets.cellName(rowNumber, colNumber);
413                     defaultCreateCell(graph, row, location, new Variant(Bindings.STRING, ""));
414                 }
415             }
416         }
417         
418         cells = possibleConfigurationCellVariables(graph, sheet, range);
419         if(cells.isEmpty())
420             throw new DatabaseException("Unexpected problem while creating spreadsheet cell at '" + range + "'");
421         
422         return cells;
423     }
424     
425     private static void defaultCreateCell(WriteGraph graph, Variable parent, String location, Variant value) throws DatabaseException {
426
427         Layer0 L0 = Layer0.getInstance(graph);
428         SpreadsheetResource SHEET = SpreadsheetResource.getInstance(graph);
429         Resource container = parent.getRepresents(graph);
430         
431         Resource cell = graph.newResource();
432         graph.claim(cell, L0.InstanceOf, null, SHEET.TextCell);
433         graph.addLiteral(cell, L0.HasName, L0.NameOf, L0.String, location, Bindings.STRING);
434         graph.addLiteral(cell, SHEET.Cell_content, SHEET.Cell_content_Inverse, L0.Variant, value, Bindings.VARIANT);
435         graph.claim(cell, L0.PartOf, container);
436         
437         Resource book = Variables.getContext(graph, parent).getRepresents(graph);
438         
439         
440         Collection<Resource> objects = graph.sync(new ObjectsWithType(book, L0.ConsistsOf, SHEET.Style));
441         
442         int styleId = SpreadsheetStyle.empty().getStyleId();
443         Resource style = null;
444         for (Resource possibleStyle : objects) {
445             int possibleStyleId = graph.getRelatedValue2(possibleStyle, SHEET.Style_id, Bindings.INTEGER);
446             if (possibleStyleId == styleId) {
447                 style = possibleStyle;
448                 break;
449             }
450         }
451         
452         if (style == null) {
453             style = graph.newResource();
454             graph.claim(style, L0.InstanceOf, null, SHEET.Style);
455             graph.claim(style, L0.PartOf, book);
456             
457             int id = objects.size();
458             graph.claimLiteral(style, L0.HasName, "Style_" + id);
459             graph.claimLiteral(style, SHEET.Style_id, styleId, Bindings.INTEGER);
460         }
461         graph.claim(cell, SHEET.Cell_HasStyle, style);
462         Layer0Utils.addCommentMetadata(graph, "Created cell on location " + location + " with value " + value.toString());
463     }
464
465     public static Resource createStyle(WriteGraph graph, Resource book, SpreadsheetStyle sstyle) throws DatabaseException {
466         Layer0 L0 = Layer0.getInstance(graph);
467         SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
468         Resource style = graph.newResource();
469         graph.claim(style, L0.InstanceOf, null, SR.Style);
470         graph.claim(style, L0.PartOf, book);
471         
472         int styleId = sstyle.getStyleId();
473         String styleName = sstyle.name;
474         
475         graph.claimLiteral(style, L0.HasName, styleName);
476         //System.err.println("CREATING STYLE " + styleName + " WITH ID: " + styleId);
477         graph.claimLiteral(style, SR.Style_id, styleId, Bindings.INTEGER);
478         
479         DatatypeResource DATATYPES = DatatypeResource.getInstance(graph);
480         if (sstyle.foreground != null)
481             graph.claimLiteral(style, SR.Cell_foreground, DATATYPES.RGB_Integer, sstyle.foreground, RGB.Integer.BINDING);
482         if (sstyle.background != null)
483             graph.claimLiteral(style, SR.Cell_background, DATATYPES.RGB_Integer, sstyle.background, RGB.Integer.BINDING);
484         if (sstyle.align != -1)
485             graph.claimLiteral(style, SR.Cell_align, sstyle.align, Bindings.INTEGER);
486         if (sstyle.font != null)
487             graph.claimLiteral(style, SR.Cell_font, DATATYPES.Font, sstyle.font, Font.BINDING);
488         if (sstyle.border != -1)
489             graph.claimLiteral(style, SR.Cell_border, sstyle.border);
490         if (sstyle.formatString != null && !sstyle.formatString.isEmpty())
491             graph.claimLiteral(style, SR.Cell_formatString, sstyle.formatString, Bindings.STRING);
492         if (sstyle.formatIndex != -1)
493             graph.claimLiteral(style, SR.Cell_formatIndex, sstyle.formatIndex, Bindings.INTEGER);
494         
495         return style;
496     }
497     
498     public static Resource createBook(WriteGraph graph, Resource parent, String name) throws DatabaseException {
499         Layer0 L0 = Layer0.getInstance(graph);
500         SpreadsheetResource SR = SpreadsheetResource.getInstance(graph);
501         Resource book = graph.newResource();
502         graph.claim(book, L0.InstanceOf, SR.Book);
503         graph.claimLiteral(book, L0.HasName, L0.NameOf, L0.String, name, Bindings.STRING);
504         graph.claim(parent, L0.ConsistsOf, book);
505         
506         return book;
507     }
508     
509     public static Variable constructAndInitializeRunVariable(WriteGraph graph, Resource root) throws DatabaseException {
510         Variable run = SpreadsheetUtils.getBookVariable(graph, root);
511         SpreadsheetGraphUtils.fullSynchronization(graph, run);
512         SpreadsheetGraphUtils.evaluateAll(graph, run);
513         SpreadsheetGraphUtils.saveInitialCondition(graph, run, root, "Initial");
514         return run;
515     }
516     
517     public static Variant extRefVariable(ReadGraph graph, Variable var) throws DatabaseException {
518         return new Variant(Bindings.VOID, new ExternalRefVariable(graph, var));
519     }
520     
521     static class ExternalRefVariable implements ExternalRef {
522
523         final private String uri;
524         
525         public ExternalRefVariable(ReadGraph graph, Variable variable) throws DatabaseException {
526             this.uri = variable.getURI(graph);
527         }
528         
529         @Override
530         public void listen(Object context, ExternalRefListener listener) {
531             Simantics.getSession().asyncRequest(new UnaryRead<String, Variant>(uri) {
532
533                 @Override
534                 public Variant perform(ReadGraph graph) throws DatabaseException {
535                     Variable variable = Variables.getVariable(graph, parameter);
536                     return variable.getVariantValue(graph);
537                 }
538                 
539             }, new Listener<Variant>() {
540
541                 @Override
542                 public void execute(Variant result) {
543                     listener.newValue(result);
544                 }
545
546                 @Override
547                 public void exception(Throwable t) {
548                     LOGGER.error("Error while evaluating variable value", t);
549                 }
550
551                 @Override
552                 public boolean isDisposed() {
553                     return listener.isDisposed();
554                 }
555                 
556             });
557         }
558         
559         @Override
560         public void modify(Object context, Variant newValue) {
561             
562             Simantics.getSession().asyncRequest(new WriteRequest() {
563
564                 @Override
565                 public void perform(WriteGraph graph) throws DatabaseException {
566                     Variable variable = Variables.getVariable(graph, uri);
567                     variable.setValue(graph, newValue);
568                 }
569             });
570             
571         }
572         
573     }
574
575     public static Variant extRefActiveVariable(ReadGraph graph, Variable var) throws DatabaseException {
576         return new Variant(Bindings.VOID, new ExternalRefActiveVariable(graph, var));
577     }
578     
579     static class ExternalRefActiveVariable implements ExternalRef {
580
581         final private String uri;
582         
583         public ExternalRefActiveVariable(ReadGraph graph, Variable variable) throws DatabaseException {
584             this.uri = variable.getURI(graph);
585         }
586         
587         @Override
588         public void listen(Object context, ExternalRefListener listener) {
589             Simantics.getSession().asyncRequest(new BinaryRead<String, String, Variant>((String)context, uri) {
590
591                 @Override
592                 public Variant perform(ReadGraph graph) throws DatabaseException {
593                     Variable contextVariable = Variables.getVariable(graph, parameter);
594                     Variable configVariable = Variables.getVariable(graph, parameter2);
595                     Variable activeVariable = Variables.switchPossibleContext(graph, configVariable, contextVariable.getRepresents(graph));
596                     if(activeVariable == null) return Variant.ofInstance("Could not resolve " + configVariable.getURI(graph) + " for " + contextVariable.getURI(graph));
597                     return activeVariable.getVariantValue(graph);
598                 }
599             }, new Listener<Variant>() {
600
601                 @Override
602                 public void execute(Variant result) {
603                     listener.newValue(result);
604                 }
605
606                 @Override
607                 public void exception(Throwable t) {
608                     LOGGER.error("Error while evaluating variable value, context = " + context + " uri=" + uri, t);
609                 }
610
611                 @Override
612                 public boolean isDisposed() {
613                     return listener.isDisposed();
614                 }
615                 
616             });
617         }
618         
619         @Override
620         public void modify(Object context, Variant newValue) {
621             
622             Simantics.getSession().asyncRequest(new WriteRequest() {
623
624                 @Override
625                 public void perform(WriteGraph graph) throws DatabaseException {
626                     Variable contextVariable = Variables.getVariable(graph, (String)context);
627                     Variable configVariable = Variables.getVariable(graph,uri);
628                     Variable activeVariable = Variables.switchPossibleContext(graph, configVariable, contextVariable.getRepresents(graph));
629                     if(activeVariable == null) return;
630                     activeVariable.setValue(graph, newValue.getValue(), newValue.getBinding());
631                 }
632             });
633             
634         }
635         
636     }
637     
638     public static CellEditor cellEditor(ReadGraph graph, Resource sheet) throws DatabaseException {
639         SpreadsheetResource SHEET = SpreadsheetResource.getInstance(graph);
640         Variable sheetVariable = Variables.getVariable(graph, sheet);
641         return sheetVariable.getPropertyValue(graph, SHEET.cellEditor);
642     }
643     
644     public static final String SPREADSHEET_TRANSACTION = "spreadsheetTransaction";
645
646     @SuppressWarnings({ "rawtypes", "unchecked" })
647     public static Object syncExec(CellEditor editor, OperationMode mode, Function fun) throws InterruptedException {
648         
649         Transaction tr = editor.startTransaction(mode);
650         
651         SCLContext context = SCLContext.getCurrent();
652         Transaction oldTransaction = (Transaction)context.put(SPREADSHEET_TRANSACTION, tr);
653         
654         Object result = null;
655         
656         try {
657
658             result = fun.apply(Tuple0.INSTANCE);
659             
660         } finally {
661             
662             tr.commit();
663             
664             context.put(SPREADSHEET_TRANSACTION, oldTransaction);
665             
666         }
667         
668         return result;
669         
670     }
671     
672     public static int cellColumn(ReadGraph graph, Variable cell) {
673         if(cell instanceof StandardGraphChildVariable) {
674             StandardGraphChildVariable sgcv = (StandardGraphChildVariable)cell;
675             SpreadsheetCell sc = (SpreadsheetCell)sgcv.node.node;
676             return sc.getColumn();
677         }
678         throw new IllegalStateException("Expected StandardGraphChildVariable, got " + cell.getClass().getName());
679     }
680     
681     private static SpreadsheetCell getCellFromVariable(Variable cell) {
682         StandardGraphChildVariable std =  (StandardGraphChildVariable)cell;
683         return (SpreadsheetCell)std.node.node;
684     }
685     
686     private static SpreadsheetLine getLineFromVariable(Variable cell) {
687         StandardGraphChildVariable std =  (StandardGraphChildVariable)cell;
688         return (SpreadsheetLine)std.node.node;
689     }
690
691     public static Variable linesVariable(ReadGraph graph, Variable sheetVariable) throws DatabaseException {
692         while(!"Lines".equals(sheetVariable.getName(graph)))
693             sheetVariable = sheetVariable.getParent(graph);
694         return sheetVariable;
695     }
696     
697     public static Variable offsetCell(ReadGraph graph, Variable cellVariable, int x, int y) throws DatabaseException {
698         
699         Variable lineVariable = cellVariable.getParent(graph);
700         Variable offsetLine = offsetRow(graph, lineVariable, y);
701         if(offsetLine == null) return null;
702         SpreadsheetCell cell = getCellFromVariable(cellVariable);
703         return rowCell(graph, offsetLine, cell.column + x);
704         
705     }
706
707     public static Variable offsetRow(ReadGraph graph, Variable lineVariable, int offset) throws DatabaseException {
708         
709         if(offset == 0) return lineVariable;
710
711         SpreadsheetLine line = getLineFromVariable(lineVariable);
712         SpreadsheetLine offsetLine = line.possibleOffset(offset);
713         if(offsetLine == null) return null;
714         
715         Variable linesVariable = linesVariable(graph, lineVariable);
716         String path = offsetLine.getLinesPath();
717         return linesVariable.browsePossible(graph, path);
718
719     }
720     
721     public static Variable rowCell(ReadGraph graph, Variable lineVariable, int column) throws DatabaseException {
722         
723         SpreadsheetLine line = getLineFromVariable(lineVariable);
724         
725         return lineVariable.getPossibleChild(graph, Spreadsheets.cellName(line.row, column));
726         
727     }
728     
729     public static SpreadsheetBook spreadsheetBook(Variable variable) {
730         if(variable instanceof StandardGraphChildVariable) {
731             VariableNode<Node> node = ((StandardGraphChildVariable)variable).node;
732             if(node != null) {
733                 if(node.node instanceof SpreadsheetBook)
734                     return (SpreadsheetBook) node.node;
735             }
736         }
737         return null;
738     }
739     
740 }