bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/modelBrowser/ModelEvaluators.java

   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
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.modeling.ui.modelBrowser;\r
  13 \r
  14 import java.util.ArrayList;\r
  15 import java.util.Collection;\r
  16 import java.util.Collections;\r
  17 import java.util.HashSet;\r
  18 import java.util.Map;\r
  19 import java.util.Set;\r
  20 import java.util.function.Supplier;\r
  21 \r
  22 import org.eclipse.jface.resource.ImageDescriptor;\r
  23 import org.simantics.browsing.ui.BuiltinKeys;\r
  24 import org.simantics.browsing.ui.BuiltinKeys.ImagerKey;\r
  25 import org.simantics.browsing.ui.BuiltinKeys.LabelerKey;\r
  26 import org.simantics.browsing.ui.BuiltinKeys.ViewpointKey;\r
  27 import org.simantics.browsing.ui.DataSource;\r
  28 import org.simantics.browsing.ui.GraphExplorer.ModificationContext;\r
  29 import org.simantics.browsing.ui.NodeContext;\r
  30 import org.simantics.browsing.ui.PrimitiveQueryUpdater;\r
  31 import org.simantics.browsing.ui.common.ColumnKeys;\r
  32 import org.simantics.browsing.ui.common.EvaluatorData.Evaluator;\r
  33 import org.simantics.browsing.ui.common.EvaluatorImpl;\r
  34 import org.simantics.browsing.ui.common.comparators.AlphanumericComparatorFactory;\r
  35 import org.simantics.browsing.ui.common.imagers.ContainerImager;\r
  36 import org.simantics.browsing.ui.common.labelers.LabelerContent;\r
  37 import org.simantics.browsing.ui.common.labelers.LabelerStub;\r
  38 import org.simantics.browsing.ui.common.viewpoints.ViewpointStub;\r
  39 import org.simantics.browsing.ui.content.Imager;\r
  40 import org.simantics.browsing.ui.content.ImagerFactory;\r
  41 import org.simantics.browsing.ui.content.Labeler;\r
  42 import org.simantics.browsing.ui.content.LabelerFactory;\r
  43 import org.simantics.browsing.ui.content.Viewpoint;\r
  44 import org.simantics.browsing.ui.content.ViewpointFactory;\r
  45 import org.simantics.browsing.ui.graph.impl.LazyGraphLabeler;\r
  46 import org.simantics.browsing.ui.graph.impl.LazyViewpoint;\r
  47 import org.simantics.browsing.ui.graph.impl.MissingImageDescriptor;\r
  48 import org.simantics.browsing.ui.graph.impl.StringRepresentationLabelerFactory;\r
  49 import org.simantics.browsing.ui.swt.OldAdapterImagerFactory;\r
  50 import org.simantics.db.ReadGraph;\r
  51 import org.simantics.db.Resource;\r
  52 import org.simantics.db.exception.DatabaseException;\r
  53 import org.simantics.layer0.Layer0;\r
  54 import org.simantics.modeling.ui.modelBrowser.model.IChildrenCallback;\r
  55 import org.simantics.modeling.ui.modelBrowser.model.IDisposable;\r
  56 import org.simantics.modeling.ui.modelBrowser.model.INode;\r
  57 import org.simantics.modeling.ui.modelBrowser.model.INode2;\r
  58 import org.simantics.modeling.ui.modelBrowser.model.IUpdateable;\r
  59 import org.simantics.ui.SimanticsUI;\r
  60 import org.simantics.utils.datastructures.UnaryFunction;\r
  61 \r
  62 /**\r
  63  * @author Hannu Niemist&ouml;\r
  64  * @author Tuukka Lehtonen\r
  65  */\r
  66 @Deprecated\r
  67 public final class ModelEvaluators {\r
  68 \r
  69     public static UnaryFunction<Boolean, Object> passTester() {\r
  70         return new UnaryFunction<Boolean, Object>() {\r
  71             @Override\r
  72             public Boolean call(Object arg) {\r
  73                 return Boolean.TRUE;\r
  74             }\r
  75         };\r
  76     }\r
  77 \r
  78     public static UnaryFunction<Boolean, Object> exactClassTester(final Class<?> ... classes) {\r
  79         final Set<Class<?>> classSet = new HashSet<Class<?>>();\r
  80         for(Class<?> clazz : classes) classSet.add(clazz);\r
  81         return new UnaryFunction<Boolean, Object>() {\r
  82             @Override\r
  83             public Boolean call(Object arg) {\r
  84                 if(classSet.contains(arg.getClass())) return Boolean.TRUE;\r
  85                 return Boolean.FALSE;\r
  86             }\r
  87         };\r
  88     }\r
  89 \r
  90     public static UnaryFunction<Boolean, Object> classTester(final Class<?> ... classes) {\r
  91         return new UnaryFunction<Boolean, Object>() {\r
  92             @Override\r
  93             public Boolean call(Object arg) {\r
  94                 for(Class<?> clazz : classes) {\r
  95                     if(clazz.isInstance(arg)) return Boolean.TRUE;\r
  96                 }\r
  97                 return Boolean.FALSE;\r
  98             }\r
  99         };\r
 100     }\r
 101 \r
 102     /**\r
 103      * @param session\r
 104      * @param resourceManager\r
 105      * @param factoryHints\r
 106      * @return\r
 107      */\r
 108     public static Evaluator createResourceEvaluator() {\r
 109         Evaluator resourceEvaluator = new EvaluatorImpl();\r
 110 \r
 111         resourceEvaluator.addViewpoint(new ResourceViewpointFactory(), 1.0);\r
 112         resourceEvaluator.addComparator(new AlphanumericComparatorFactory(ColumnKeys.SINGLE), 2.0);\r
 113         resourceEvaluator.addLabeler(new StringRepresentationLabelerFactory(), 1.0);\r
 114         resourceEvaluator.addImager(new OldAdapterImagerFactory(), 1.0);\r
 115 \r
 116         return resourceEvaluator;\r
 117     }\r
 118 \r
 119     /**\r
 120      * @param session\r
 121      * @param resourceManager\r
 122      * @param factoryHints\r
 123      * @param tester\r
 124      * @return\r
 125      */\r
 126     public static Evaluator createResourceEvaluator(final UnaryFunction<Boolean, Object> tester) {\r
 127         Evaluator resourceEvaluator = new EvaluatorImpl();\r
 128 \r
 129         resourceEvaluator.addViewpoint(new ResourceViewpointFactoryWithTester(tester), 1.0);\r
 130         resourceEvaluator.addComparator(new AlphanumericComparatorFactory(ColumnKeys.SINGLE), 2.0);\r
 131         resourceEvaluator.addLabeler(new StringRepresentationLabelerFactory(), 1.0);\r
 132         resourceEvaluator.addImager(new OldAdapterImagerFactory(), 1.0);\r
 133 \r
 134         return resourceEvaluator;\r
 135     }\r
 136 \r
 137     /**\r
 138      * @param session\r
 139      * @param resourceManager\r
 140      * @return\r
 141      */\r
 142     public static Evaluator createNodeEvaluator() {\r
 143         Evaluator nodeEvaluator = new EvaluatorImpl();\r
 144 \r
 145         nodeEvaluator.addViewpoint(new NodeViewpointFactory(), 1.0);\r
 146         nodeEvaluator.addComparator(new AlphanumericComparatorFactory(ColumnKeys.SINGLE), 2.0);\r
 147         nodeEvaluator.addLabeler(new NodeLabelerFactory(), 1.0);\r
 148         nodeEvaluator.addImager(new NodeImagerFactory(), 1.0);\r
 149 \r
 150         return nodeEvaluator;\r
 151     }\r
 152 \r
 153     /**\r
 154      * @param session\r
 155      * @param resourceManager\r
 156      * @param tester\r
 157      * @return\r
 158      */\r
 159     public static Evaluator createNodeEvaluator(final UnaryFunction<Boolean, Object> tester) {\r
 160         Evaluator nodeEvaluator = new EvaluatorImpl();\r
 161 \r
 162         nodeEvaluator.addViewpoint(new NodeViewpointFactoryWithTester(tester), 1.0);\r
 163         nodeEvaluator.addComparator(new AlphanumericComparatorFactory(ColumnKeys.SINGLE), 2.0);\r
 164         nodeEvaluator.addLabeler(new NodeLabelerFactory(), 1.0);\r
 165         nodeEvaluator.addImager(new NodeImagerFactory(), 1.0);\r
 166 \r
 167         return nodeEvaluator;\r
 168     }\r
 169 \r
 170     /**\r
 171      * @param session\r
 172      * @param resourceManager\r
 173      * @return\r
 174      */\r
 175     public static Evaluator createNode2Evaluator() {\r
 176         Evaluator nodeEvaluator = new EvaluatorImpl();\r
 177 \r
 178         nodeEvaluator.addViewpoint(new Node2ViewpointFactory(), 1.0);\r
 179         nodeEvaluator.addComparator(new AlphanumericComparatorFactory(ColumnKeys.SINGLE), 2.0);\r
 180         nodeEvaluator.addLabeler(new Node2LabelerFactory(), 1.0);\r
 181         nodeEvaluator.addImager(new Node2ImagerFactory(), 1.0);\r
 182 \r
 183         return nodeEvaluator;\r
 184     }\r
 185 \r
 186 }\r
 187 \r
 188 abstract class BaseViewpointFactory implements ViewpointFactory {\r
 189     protected abstract class VPB extends LazyViewpoint implements Supplier<Boolean>, IChildrenCallback {\r
 190         public VPB(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 191             super(updater, context, key);\r
 192         }\r
 193 \r
 194         @Override\r
 195         public String toString() {\r
 196             return BaseViewpointFactory.this.toString();\r
 197         }\r
 198 \r
 199         @Override\r
 200         public Object getIdentity() {\r
 201             // This is necessary to give graph requests related to this\r
 202             // LazyViewpoint a unique-enough identity so that they don't collide\r
 203             // unexpectedly with other users of ModelEvaluators.\r
 204             // This makes requests created with different concrete classes of\r
 205             // BaseViewpointFactory unique.\r
 206             return BaseViewpointFactory.this.getClass();\r
 207         }\r
 208 \r
 209         @Override\r
 210         public Boolean get() {\r
 211             return Boolean.valueOf(updater.isDisposed());\r
 212         }\r
 213 \r
 214         @Override\r
 215         public void refreshChildren(Collection<?> newChildren) {\r
 216             NodeContext[] ncs = toContextsWithInput(newChildren);\r
 217             setHasChildren(ncs.length > 0);\r
 218             setChildren(updater, ncs);\r
 219             updater.scheduleReplace(context, key, this);\r
 220         }\r
 221 \r
 222         @Override\r
 223         public Boolean hasChildren(ReadGraph graph) throws DatabaseException {\r
 224             // hasChildren must do the same graph operations as children\r
 225             // since they both share the same PrimitiveQueryUpdater.\r
 226             return children(graph).length > 0;\r
 227         }\r
 228     };\r
 229 }\r
 230 \r
 231 abstract class BaseViewpointFactoryWithTester extends BaseViewpointFactory {\r
 232     protected final UnaryFunction<Boolean, Object> tester;\r
 233 \r
 234     BaseViewpointFactoryWithTester(UnaryFunction<Boolean, Object> tester) {\r
 235         this.tester = tester;\r
 236     }\r
 237 }\r
 238 \r
 239 class ResourceViewpointFactory extends BaseViewpointFactory {\r
 240     @Override\r
 241     public String toString() {\r
 242         return "Consists Of";\r
 243     }\r
 244 \r
 245     class VP extends VPB {\r
 246         public VP(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 247             super(updater, context, key);\r
 248         }\r
 249 \r
 250         @Override\r
 251         public NodeContext[] children(ReadGraph graph) throws DatabaseException {\r
 252             return toContextsWithInput( getChildren(graph, (Resource) context.getConstant(BuiltinKeys.INPUT)) );\r
 253         }\r
 254 \r
 255         protected Collection<?> getChildren(ReadGraph g, Resource r) throws DatabaseException {\r
 256                 Layer0 b = Layer0.getInstance(g);\r
 257             Collection<Resource> resources = g.getObjects(r, b.ConsistsOf);\r
 258             ArrayList<Object> ret = new ArrayList<Object>(resources.size());\r
 259             for (Resource res : resources) {\r
 260                 Object node = null;\r
 261 //              try {\r
 262 //                  node = g.adapt2(res, INode2.class));\r
 263 //              } catch (AdaptionException e) {\r
 264                 node = g.getPossibleAdapter(res, INode.class);\r
 265                 if (node != null) {\r
 266                     if (node instanceof IDisposable)\r
 267                         ((IDisposable) node).setDisposedCallable(this);\r
 268 //                    if (node instanceof IUpdateable)\r
 269 //                        ((IUpdateable) node).setChildrenCallback(this);\r
 270                     ret.add(node);\r
 271 //                  }\r
 272                 }\r
 273             }\r
 274             return ret;\r
 275         }\r
 276     };\r
 277 \r
 278     @Override\r
 279     public Viewpoint create(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 280         return new VP(updater, context, key);\r
 281     }\r
 282 }\r
 283 \r
 284 class ResourceViewpointFactoryWithTester extends BaseViewpointFactoryWithTester {\r
 285 \r
 286     ResourceViewpointFactoryWithTester(UnaryFunction<Boolean, Object> tester) {\r
 287         super(tester);\r
 288     }\r
 289 \r
 290     @Override\r
 291     public String toString() {\r
 292         return "Consists Of";\r
 293     }\r
 294 \r
 295     class VP extends VPB {\r
 296         public VP(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 297             super(updater, context, key);\r
 298         }\r
 299 \r
 300         @Override\r
 301         public NodeContext[] children(ReadGraph graph) throws DatabaseException {\r
 302             return toContextsWithInput( getChildren(graph, (Resource) context.getConstant(BuiltinKeys.INPUT)) );\r
 303         }\r
 304 \r
 305         protected Collection<?> getChildren(ReadGraph g, Resource r) throws DatabaseException {\r
 306                 Layer0 b = Layer0.getInstance(g);\r
 307             Collection<Resource> resources = g.getObjects(r, b.ConsistsOf);\r
 308             ArrayList<Object> ret = new ArrayList<Object>(resources.size());\r
 309             for (Resource res : resources) {\r
 310                 Object node = null;\r
 311 //              try {\r
 312 //                  node = g.adapt2(res, INode2.class));\r
 313 //              } catch (AdaptionException e) {\r
 314                 node = g.getPossibleAdapter(res, INode.class);\r
 315                 if (node != null) {\r
 316                     if (tester.call(node)) {\r
 317                         if (node instanceof IDisposable)\r
 318                             ((IDisposable) node).setDisposedCallable(this);\r
 319 //                        if (node instanceof IUpdateable)\r
 320 //                            ((IUpdateable) node).setChildrenCallback(this);\r
 321                         ret.add(node);\r
 322                     }\r
 323                 }\r
 324 //              }\r
 325             }\r
 326             return ret;\r
 327         }\r
 328     };\r
 329 \r
 330     @Override\r
 331     public Viewpoint create(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 332         return new VP(updater, context, key);\r
 333     }\r
 334 }\r
 335 \r
 336 class NodeViewpointFactory extends BaseViewpointFactory {\r
 337     @Override\r
 338     public String toString() {\r
 339         return "Standard";\r
 340     }\r
 341 \r
 342     class VP extends VPB {\r
 343         public VP(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 344             super(updater, context, key);\r
 345         }\r
 346 \r
 347         @Override\r
 348         public NodeContext[] children(ReadGraph graph) throws DatabaseException {\r
 349             INode node = (INode) context.getConstant(BuiltinKeys.INPUT);\r
 350             if (node instanceof IUpdateable)\r
 351                 ((IUpdateable) node).setChildrenCallback(this);\r
 352 \r
 353             Collection<?> children = node.getChildren(graph);\r
 354             for (Object child : children) {\r
 355                 if (child instanceof IDisposable)\r
 356                     ((IDisposable) child).setDisposedCallable(this);\r
 357             }\r
 358             return toContextsWithInput(children);\r
 359         }\r
 360     };\r
 361 \r
 362     @Override\r
 363     public Viewpoint create(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 364         return new VP(updater, context, key);\r
 365     }\r
 366 }\r
 367 \r
 368 class NodeViewpointFactoryWithTester extends BaseViewpointFactoryWithTester {\r
 369 \r
 370     NodeViewpointFactoryWithTester(final UnaryFunction<Boolean, Object> tester) {\r
 371         super(tester);\r
 372     }\r
 373 \r
 374     @Override\r
 375     public String toString() {\r
 376         return "Standard";\r
 377     }\r
 378 \r
 379     class VP extends VPB {\r
 380         public VP(PrimitiveQueryUpdater updater, NodeContext context, ViewpointKey key) {\r
 381             super(updater, context, key);\r
 382         }\r
 383 \r
 384         @Override\r
 385         public NodeContext[] children(ReadGraph graph) throws DatabaseException {\r
 386             INode node = (INode) context.getConstant(BuiltinKeys.INPUT);\r
 387             if (node instanceof IUpdateable)\r
 388                 ((IUpdateable) node).setChildrenCallback(this);\r
 389 \r
 390             ArrayList<Object> result = new ArrayList<Object>();\r
 391             for (Object child : node.getChildren(graph)) {\r
 392                 if (tester.call(child)) {\r
 393                     result.add(child);\r
 394                     if (child instanceof IDisposable)\r
 395                         ((IDisposable) child).setDisposedCallable(this);\r
 396                 }\r
 397             }\r
 398             return toContextsWithInput(result);\r
 399         }\r
 400     }\r
 401 \r
 402     @Override\r
 403     public Viewpoint create(PrimitiveQueryUpdater updater,NodeContext context, ViewpointKey key) {\r
 404         return new VP(updater, context, key);\r
 405     }\r
 406 \r
 407 }\r
 408 \r
 409 class NodeLabelerFactory implements LabelerFactory {\r
 410     @Override\r
 411     public Labeler create(PrimitiveQueryUpdater updater, final NodeContext context, LabelerKey key) {\r
 412         return new LazyGraphLabeler(updater, context, key) {\r
 413             @Override\r
 414             public Object getIdentity(LabelerKey key) {\r
 415                 return NodeLabelerFactory.this.getClass();\r
 416             }\r
 417 \r
 418             @Override\r
 419             public Map<String, String> labels(ReadGraph graph) throws DatabaseException {\r
 420                 return Collections.singletonMap(ColumnKeys.SINGLE,\r
 421                         ((INode) context.getConstant(BuiltinKeys.INPUT)).getLabel(graph));\r
 422             }\r
 423 \r
 424             @Override\r
 425             public Modifier getModifier(ModificationContext sourcePart, String key) {\r
 426                 return ((INode) context.getConstant(BuiltinKeys.INPUT)).getModifier(SimanticsUI.getSession(), key);\r
 427             }\r
 428 \r
 429             @Override\r
 430             public int category(ReadGraph graph) throws DatabaseException {\r
 431                 return ((INode) context.getConstant(BuiltinKeys.INPUT)).getCategory(graph);\r
 432             }\r
 433         };\r
 434     }\r
 435 }\r
 436 \r
 437 class NodeImagerFactory implements ImagerFactory {\r
 438 \r
 439     @Override\r
 440     public Imager create(final PrimitiveQueryUpdater updater, final NodeContext context, final ImagerKey key) {\r
 441         final ContainerImager<ImageDescriptor> result = new ContainerImager<ImageDescriptor>();\r
 442         result.setImage(MissingImageDescriptor.getInstance());\r
 443 \r
 444         DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);\r
 445 \r
 446         source.schedule(g -> {\r
 447             try {\r
 448                 ImageDescriptor descriptor = ((INode)context.getConstant(BuiltinKeys.INPUT)).getImage(g);\r
 449                 result.setImage(descriptor);\r
 450                 updater.scheduleReplace(context, key, result);\r
 451             } catch (DatabaseException e) {\r
 452                 e.printStackTrace();\r
 453             }\r
 454         });\r
 455 \r
 456         return result;\r
 457     }\r
 458 \r
 459 }\r
 460 \r
 461 class Node2ViewpointFactory implements ViewpointFactory {\r
 462 \r
 463     @Override\r
 464     public String toString() {\r
 465         return "Standard";\r
 466     }\r
 467 \r
 468     @Override\r
 469     public Viewpoint create(final PrimitiveQueryUpdater updater, final NodeContext context, final ViewpointKey key) {\r
 470         class V extends ViewpointStub implements Runnable, Supplier<Boolean> {\r
 471             @Override\r
 472             public void run() {\r
 473                 updater.scheduleReplace(context, key, V.this);\r
 474             }\r
 475 \r
 476             @Override\r
 477             public Boolean get() {\r
 478                 return Boolean.valueOf(updater.isDisposed());\r
 479             }\r
 480 \r
 481             @Override\r
 482             public NodeContext[] getChildren() {\r
 483                 Collection<?> children = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getChildren(this, context);\r
 484                 for (Object child : children) {\r
 485                     if (child instanceof IDisposable)\r
 486                         ((IDisposable) child).setDisposedCallable(this);\r
 487                 }\r
 488                 return toContextsWithInput(children);\r
 489             }\r
 490 \r
 491             @Override\r
 492             public Boolean getHasChildren() {\r
 493                 return ((INode2) context.getConstant(BuiltinKeys.INPUT)).hasChildren(this, context);\r
 494             }\r
 495         }\r
 496 \r
 497         return new V();\r
 498     }\r
 499 }\r
 500 \r
 501 class Node2LabelerFactory implements LabelerFactory {\r
 502 \r
 503     @Override\r
 504     public Labeler create(final PrimitiveQueryUpdater updater, final NodeContext context, final LabelerKey key) {\r
 505 \r
 506         class L extends LabelerStub implements Runnable {\r
 507             @Override\r
 508             public Modifier getModifier(ModificationContext sourcePart, String key) {\r
 509                 return ((INode2)context.getConstant(BuiltinKeys.INPUT)).getModifier(key);\r
 510             }\r
 511             @Override\r
 512             public void run() {\r
 513                 String label = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getLabel(this, context);\r
 514                 int category = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getCategory(this, context);\r
 515                 setContent(new LabelerContent(category, Collections.singletonMap(ColumnKeys.SINGLE, label)));\r
 516                 updater.scheduleReplace(context, key, this);\r
 517             }\r
 518         };\r
 519 \r
 520         L result = new L();\r
 521 \r
 522         String label = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getLabel(result, context);\r
 523         int category = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getCategory(result, context);\r
 524         result.setContent(new LabelerContent(category, Collections.singletonMap(ColumnKeys.SINGLE, label)));\r
 525 \r
 526         return result;\r
 527     }\r
 528 \r
 529 }\r
 530 \r
 531 class Node2ImagerFactory implements ImagerFactory {\r
 532 \r
 533     @Override\r
 534     public Imager create(final PrimitiveQueryUpdater updater, final NodeContext context, final ImagerKey key) {\r
 535         assert(updater != null);\r
 536         assert(context != null);\r
 537 \r
 538         final ContainerImager<ImageDescriptor> result = new ContainerImager<ImageDescriptor>();\r
 539 \r
 540         Runnable callback = new Runnable() {\r
 541             @Override\r
 542             public void run() {\r
 543                 ImageDescriptor desc = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getImage(this, context);\r
 544                 result.setImage(desc);\r
 545                 updater.scheduleReplace(context, key, result);\r
 546             }\r
 547         };\r
 548 \r
 549         ImageDescriptor desc = ((INode2) context.getConstant(BuiltinKeys.INPUT)).getImage(callback, context);\r
 550         result.setImage(desc);\r
 551         return result;\r
 552 \r
 553     }\r
 554 \r
 555 }\r