bundles/org.simantics.browsing.ui.graph.impl/src/org/simantics/browsing/ui/graph/impl/Evaluators.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 java.util.ArrayList;
  15 import java.util.Collection;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.Map;
  19 import java.util.Set;
  20
  21 import org.eclipse.jface.resource.ResourceManager;
  22 import org.simantics.browsing.ui.BuiltinKeys.CheckedStateKey;
  23 import org.simantics.browsing.ui.BuiltinKeys.ImageDecoratorKey;
  24 import org.simantics.browsing.ui.BuiltinKeys.ImagerKey;
  25 import org.simantics.browsing.ui.BuiltinKeys.LabelDecoratorKey;
  26 import org.simantics.browsing.ui.BuiltinKeys.LabelerKey;
  27 import org.simantics.browsing.ui.BuiltinKeys.ViewpointKey;
  28 import org.simantics.browsing.ui.CheckedState;
  29 import org.simantics.browsing.ui.NodeContext;
  30 import org.simantics.browsing.ui.PrimitiveQueryUpdater;
  31 import org.simantics.browsing.ui.Tester;
  32 import org.simantics.browsing.ui.common.EvaluatorData;
  33 import org.simantics.browsing.ui.common.EvaluatorData.Evaluator;
  34 import org.simantics.browsing.ui.common.EvaluatorData.EvaluatorTree;
  35 import org.simantics.browsing.ui.common.EvaluatorDataImpl;
  36 import org.simantics.browsing.ui.common.EvaluatorImpl;
  37 import org.simantics.browsing.ui.common.exception.InvalidBrowserIdException;
  38 import org.simantics.browsing.ui.common.extension.CheckedStateContributorBindingExtensionManager;
  39 import org.simantics.browsing.ui.common.extension.ComparableContextContributorBindingExtensionManager;
  40 import org.simantics.browsing.ui.common.extension.EvaluatorBindingExtensionManager;
  41 import org.simantics.browsing.ui.common.extension.EvaluatorFactory;
  42 import org.simantics.browsing.ui.common.extension.ImageDecoratorContributorBindingExtensionManager;
  43 import org.simantics.browsing.ui.common.extension.ImagerContributorBindingExtensionManager;
  44 import org.simantics.browsing.ui.common.extension.LabelDecoratorContributorBindingExtensionManager;
  45 import org.simantics.browsing.ui.common.extension.LabelerContributorBindingExtensionManager;
  46 import org.simantics.browsing.ui.common.extension.ViewpointContributionContributorBindingExtensionManager;
  47 import org.simantics.browsing.ui.content.CheckedStateFactory;
  48 import org.simantics.browsing.ui.content.ComparableContextFactory;
  49 import org.simantics.browsing.ui.content.ContributorBinding;
  50 import org.simantics.browsing.ui.content.ImageDecorator;
  51 import org.simantics.browsing.ui.content.ImageDecoratorFactory;
  52 import org.simantics.browsing.ui.content.Imager;
  53 import org.simantics.browsing.ui.content.ImagerFactory;
  54 import org.simantics.browsing.ui.content.LabelDecorator;
  55 import org.simantics.browsing.ui.content.LabelDecoratorFactory;
  56 import org.simantics.browsing.ui.content.Labeler;
  57 import org.simantics.browsing.ui.content.LabelerFactory;
  58 import org.simantics.browsing.ui.content.Viewpoint;
  59 import org.simantics.browsing.ui.content.ViewpointContributionFactory;
  60 import org.simantics.browsing.ui.content.ViewpointFactory;
  61 import org.simantics.browsing.ui.model.InvalidContribution;
  62 import org.simantics.browsing.ui.model.browsecontexts.BrowseContext;
  63 import org.simantics.db.ReadGraph;
  64 import org.simantics.db.RequestProcessor;
  65 import org.simantics.db.Resource;
  66 import org.simantics.db.common.request.ReadRequest;
  67 import org.simantics.db.exception.DatabaseException;
  68 import org.simantics.db.exception.ResourceNotFoundException;
  69 import org.slf4j.Logger;
  70 import org.slf4j.LoggerFactory;
  71
  72 /**
  73  * An entry point for loading an EvaluatorData in a data-oriented fashion. Also
  74  * adds contributions made by extensions of the related extension points.
  75  *
  76  * @author Antti Villberg
  77  */
  78 public class Evaluators {
  79
  80     private static final Logger LOGGER = LoggerFactory.getLogger(Evaluators.class);
  81     public static final boolean DEBUG = false;
  82
  83     public static void create(EvaluatorData data, final ResourceManager resourceManager,
  84             final Map<String, Collection<ContributorBinding<ViewpointContributionFactory>>> viewpointContributions,
  85             final Set<ContributorBinding<ComparableContextFactory>> comparableContextContributions,
  86             final Set<ContributorBinding<LabelerFactory>> labelerContributions,
  87             final Set<ContributorBinding<CheckedStateFactory>> checkStateContributions,
  88             final Set<ContributorBinding<LabelDecoratorFactory>> labelDecoratorContributions,
  89             final Set<ContributorBinding<ImagerFactory>> imagerContributions,
  90             final Set<ContributorBinding<ImageDecoratorFactory>> imageDecoratorContributions) {
  91
  92         Map<Class<?>, Evaluator> evaluators = new HashMap<Class<?>, Evaluator>();
  93
  94         HashMap<String, ContributionViewpointFactory> viewpointFactories = new HashMap<String, ContributionViewpointFactory>();
  95
  96         for(final Map.Entry<String, Collection<ContributorBinding<ViewpointContributionFactory>>> entry : viewpointContributions.entrySet()) {
  97             Collection<ViewpointContributionFactory> factories = new ArrayList<ViewpointContributionFactory>();
  98             for(ContributorBinding<ViewpointContributionFactory> binding : entry.getValue()) factories.add(binding.getContributor().getFactory());
  99             viewpointFactories.put(entry.getKey(), new ContributionViewpointFactory(entry.getKey(), factories));
 100         }
 101
 102         for(final Map.Entry<String, Collection<ContributorBinding<ViewpointContributionFactory>>> entry : viewpointContributions.entrySet()) {
 103             ContributionViewpointFactory factory = viewpointFactories.get(entry.getKey());
 104             for(ContributorBinding<ViewpointContributionFactory> binding : entry.getValue()) {
 105                 Tester test = binding.getContributor().getNodeContextTester();
 106                 Class<?> clazz = binding.getContributor().getInputClass();
 107                 Evaluator evaluator = evaluators.get(clazz);
 108                 if(evaluator == null) {
 109                     evaluator = data.newEvaluator();
 110                     evaluators.put(clazz, evaluator);
 111                 }
 112                 if(test == null) {
 113                     if (DEBUG)
 114                         System.out.println("add root viewpoint " + factory + " to class " + clazz.getSimpleName());
 115                     evaluator.addViewpoint(factory, binding.getPreference());
 116                 } else {
 117                     if (DEBUG)
 118                         System.out.println("add viewpoint " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 119                     EvaluatorTree<ViewpointFactory> branch = ((EvaluatorImpl)evaluator).getViewpointTree().addBranch(test);
 120                     branch.addFactory(factory, binding.getPreference());
 121                 }
 122             }
 123         }
 124
 125         for(final ContributorBinding<ComparableContextFactory> binding : comparableContextContributions) {
 126
 127             ComparableContextFactory factory = binding.getContributor().getFactory();
 128             Tester test = binding.getContributor().getNodeContextTester();
 129             Class<?> clazz = binding.getContributor().getInputClass();
 130             Evaluator evaluator = evaluators.get(clazz);
 131             if(evaluator == null) {
 132                 evaluator = data.newEvaluator();
 133                 evaluators.put(clazz, evaluator);
 134             }
 135             if(test == null) {
 136                 if (DEBUG)
 137                     System.out.println("add root comparable context " + factory + " to class " + clazz.getSimpleName());
 138                 evaluator.addComparableContext(factory, binding.getPreference());
 139             } else {
 140                 if (DEBUG)
 141                     System.out.println("add comparable context " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 142                 EvaluatorTree<ComparableContextFactory> branch = ((EvaluatorImpl)evaluator).getComparableContextTree().addBranch(test);
 143                 branch.addFactory(factory, binding.getPreference());
 144             }
 145         }
 146
 147         for(final ContributorBinding<LabelerFactory> binding : labelerContributions) {
 148
 149             LabelerFactory factory = binding.getContributor().getFactory();
 150             Tester test = binding.getContributor().getNodeContextTester();
 151             Class<?> clazz = binding.getContributor().getInputClass();
 152             Evaluator evaluator = evaluators.get(clazz);
 153             if(evaluator == null) {
 154                 evaluator = data.newEvaluator();
 155                 evaluators.put(clazz, evaluator);
 156             }
 157             if(test == null) {
 158                 if (DEBUG)
 159                     System.out.println("add root labeler " + factory + " to class " + clazz.getSimpleName());
 160                 evaluator.addLabeler(factory, binding.getPreference());
 161             } else {
 162                 if (DEBUG)
 163                     System.out.println("add labeler " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 164                 EvaluatorTree<LabelerFactory> branch = ((EvaluatorImpl)evaluator).getLabelerTree().addBranch(test);
 165                 branch.addFactory(factory, binding.getPreference());
 166             }
 167         }
 168
 169         for(final ContributorBinding<CheckedStateFactory> binding : checkStateContributions) {
 170
 171             CheckedStateFactory factory = binding.getContributor().getFactory();
 172             Tester test = binding.getContributor().getNodeContextTester();
 173             Class<?> clazz = binding.getContributor().getInputClass();
 174             Evaluator evaluator = evaluators.get(clazz);
 175             if(evaluator == null) {
 176                 evaluator = data.newEvaluator();
 177                 evaluators.put(clazz, evaluator);
 178             }
 179             if(test == null) {
 180                 if (DEBUG)
 181                     System.out.println("add root check state " + factory + " to class " + clazz.getSimpleName());
 182                 evaluator.addCheckState(factory, binding.getPreference());
 183             } else {
 184                 if (DEBUG)
 185                     System.out.println("add check state " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 186                 EvaluatorTree<CheckedStateFactory> branch = ((EvaluatorImpl)evaluator).getCheckStateTree().addBranch(test);
 187                 branch.addFactory(factory, binding.getPreference());
 188             }
 189         }
 190
 191         for(final ContributorBinding<LabelDecoratorFactory> binding : labelDecoratorContributions) {
 192
 193             LabelDecoratorFactory factory = binding.getContributor().getFactory();
 194             Tester test = binding.getContributor().getNodeContextTester();
 195             Class<?> clazz = binding.getContributor().getInputClass();
 196             Evaluator evaluator = evaluators.get(clazz);
 197             if(evaluator == null) {
 198                 evaluator = data.newEvaluator();
 199                 evaluators.put(clazz, evaluator);
 200             }
 201             if(test == null) {
 202                 if (DEBUG)
 203                     System.out.println("add root label decorator " + factory + " to class " + clazz.getSimpleName());
 204                 evaluator.addLabelDecorator(factory, binding.getPreference());
 205             } else {
 206                 if (DEBUG)
 207                     System.out.println("add label decorator " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 208                 EvaluatorTree<LabelDecoratorFactory> branch = ((EvaluatorImpl)evaluator).getLabelDecoratorTree().addBranch(test);
 209                 branch.addFactory(factory, binding.getPreference());
 210             }
 211         }
 212
 213         for(final ContributorBinding<ImagerFactory> binding : imagerContributions) {
 214
 215             ImagerFactory factory = binding.getContributor().getFactory();
 216             Tester test = binding.getContributor().getNodeContextTester();
 217             Class<?> clazz = binding.getContributor().getInputClass();
 218             Evaluator evaluator = evaluators.get(clazz);
 219             if(evaluator == null) {
 220                 evaluator = data.newEvaluator();
 221                 evaluators.put(clazz, evaluator);
 222             }
 223             if(test == null) {
 224                 if (DEBUG)
 225                     System.out.println("add root imager " + factory + " to class " + clazz.getSimpleName());
 226                 evaluator.addImager(factory, binding.getPreference());
 227             } else {
 228                 if (DEBUG)
 229                     System.out.println("add imager " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 230                 EvaluatorTree<ImagerFactory> branch = ((EvaluatorImpl)evaluator).getImagerTree().addBranch(test);
 231                 branch.addFactory(factory, binding.getPreference());
 232             }
 233         }
 234
 235         for(final ContributorBinding<ImageDecoratorFactory> binding : imageDecoratorContributions) {
 236
 237             ImageDecoratorFactory factory = binding.getContributor().getFactory();
 238             Tester test = binding.getContributor().getNodeContextTester();
 239             Class<?> clazz = binding.getContributor().getInputClass();
 240             Evaluator evaluator = evaluators.get(clazz);
 241             if(evaluator == null) {
 242                 evaluator = data.newEvaluator();
 243                 evaluators.put(clazz, evaluator);
 244             }
 245             if(test == null) {
 246                 if (DEBUG)
 247                     System.out.println("add root image decorator " + factory + " to class " + clazz.getSimpleName());
 248                 evaluator.addImageDecorator(factory, binding.getPreference());
 249             } else {
 250                 if (DEBUG)
 251                     System.out.println("add image decorator " + factory + " to class " + clazz.getSimpleName() + " with tester " + test);
 252                 EvaluatorTree<ImageDecoratorFactory> branch = ((EvaluatorImpl)evaluator).getImageDecoratorTree().addBranch(test);
 253                 branch.addFactory(factory, binding.getPreference());
 254             }
 255         }
 256
 257         for(Map.Entry<Class<?>, Evaluator> entry : evaluators.entrySet()) {
 258             data.addEvaluator(entry.getKey(), entry.getValue());
 259         }
 260
 261     }
 262
 263     /**
 264      * @param processor
 265      * @param browseContexts
 266      * @param resourceManager
 267      * @param data
 268      * @return the URIs of the actual set of browse contexts loaded by this
 269      *         method. If an included browse context resource has no URI, it
 270      *         will not be included in this set.
 271      */
 272     public static Set<String> loadModelled(
 273             RequestProcessor processor,
 274             final Set<String> browseContexts,
 275             final ResourceManager resourceManager,
 276             final EvaluatorDataImpl data,
 277             final boolean useNodeBrowseContexts,
 278             final boolean useNodeActionContexts) {
 279
 280         final Set<String> allBrowseContexts = new HashSet<String>(browseContexts);
 281
 282         // Create evaluator
 283         final EvaluatorImpl eval = new EvaluatorImpl();
 284         data.addEvaluator(Object.class, eval);
 285
 286         try {
 287
 288             // Load data for evaluator
 289             processor.syncRequest(new ReadRequest() {
 290
 291                 @Override
 292                 public void run(ReadGraph graph) throws DatabaseException {
 293
 294                     // Map browse context names to resources
 295                     Collection<Resource> browseContextResources = new ArrayList<Resource>(browseContexts.size());
 296                     for(String browseContext : browseContexts) {
 297                         try {
 298                             browseContextResources.add(graph.getResource(browseContext));
 299                         } catch(ResourceNotFoundException e) {
 300                             // Expected result, if the browse context is not modelled.
 301                         } catch(DatabaseException e) {
 302                             LOGGER.error("Unexpected error occurred while finding browse context " + browseContext + ".", e);
 303                         }
 304                     }
 305
 306                     // Load browse context
 307                     try {
 308                         final BrowseContext browseContext =
 309                             BrowseContext.create(graph, browseContextResources);
 310
 311                         data.setBrowseContext(browseContext);
 312
 313                         // Get URI's for all found browse contexts to fill return value
 314                         for (Resource context : BrowseContext.findSubcontexts(graph, browseContextResources)) {
 315                             String uri = graph.getPossibleURI(context);
 316                             if (uri != null)
 317                                 allBrowseContexts.add(uri);
 318                         }
 319
 320                         // Fill evaluator
 321                         eval.addLabeler(new LabelerFactory() {
 322                             @Override
 323                             public Labeler create(PrimitiveQueryUpdater updater, final NodeContext context,
 324                                     LabelerKey key) {
 325                                 return new EvaluatorLabeler(updater, context, key, browseContext, useNodeBrowseContexts);
 326                             }
 327                         }, 0.0);
 328
 329                         eval.addImager(new ImagerFactory() {
 330                             @Override
 331                             public Imager create(PrimitiveQueryUpdater updater, NodeContext context,
 332                                     ImagerKey key) {
 333                                 return new EvaluatorImager(updater, context, key, browseContext, useNodeBrowseContexts);
 334                             }
 335                         }, 0.0);
 336
 337                         eval.addCheckState(new CheckedStateFactory() {
 338
 339                             @Override
 340                             public CheckedState create(PrimitiveQueryUpdater updater,
 341                                     NodeContext context, CheckedStateKey key) {
 342                                 return new EvaluatorCheckedState(updater, context, key, browseContext, useNodeBrowseContexts).getState();
 343                             }
 344                         }, 0.0);
 345
 346                         eval.addLabelDecorator(new LabelDecoratorFactory() {
 347                             @Override
 348                             public LabelDecorator create(PrimitiveQueryUpdater updater,
 349                                     NodeContext context, LabelDecoratorKey key) {
 350                                 return new EvaluatorLabelDecorator(updater, context, key, browseContext, useNodeBrowseContexts);
 351                             }
 352                         }, 0.0);
 353
 354                         eval.addImageDecorator(new ImageDecoratorFactory() {
 355                             @Override
 356                             public ImageDecorator create(PrimitiveQueryUpdater updater,
 357                                     NodeContext context, ImageDecoratorKey key) {
 358                                 return new EvaluatorImageDecorator(updater, context, key, browseContext, useNodeBrowseContexts);
 359                             }
 360                         }, 0.0);
 361
 362                         eval.addViewpoint(new ViewpointFactory() {
 363                             @Override
 364                             public Viewpoint create(PrimitiveQueryUpdater updater,
 365                                     final NodeContext context,
 366                                     ViewpointKey key) {
 367                                 return new EvaluatorViewpoint(updater, context, key, browseContext, useNodeBrowseContexts, useNodeActionContexts);
 368                             }
 369                         }, 0.0);
 370                     } catch (InvalidContribution e) {
 371                         e.printStackTrace();
 372                         return;
 373                     }
 374
 375                 }
 376
 377             });
 378
 379         } catch (DatabaseException e) {
 380
 381             e.printStackTrace();
 382
 383         }
 384
 385         return allBrowseContexts;
 386     }
 387
 388     public static void loadExtensions(RequestProcessor processor, final Set<String> browseContexts, final ResourceManager resourceManager,
 389             final Map<String, Collection<ContributorBinding<ViewpointContributionFactory>>> viewpointContributions,
 390             final Set<ContributorBinding<ComparableContextFactory>> comparableContextContributions,
 391             final Set<ContributorBinding<LabelerFactory>> labelerContributions,
 392             final Set<ContributorBinding<CheckedStateFactory>> checkStateContributions,
 393             final Set<ContributorBinding<LabelDecoratorFactory>> labelDecoratorContributions,
 394             final Set<ContributorBinding<ImagerFactory>> imagerContributions,
 395             final Set<ContributorBinding<ImageDecoratorFactory>> imageDecoratorContributions) {
 396
 397         for(ContributorBinding<ViewpointContributionFactory> binding : ViewpointContributionContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 398             String viewpointId = binding.getContributor().getFactory().getViewpointId();
 399             Collection<ContributorBinding<ViewpointContributionFactory>> viewpoints = viewpointContributions.get(viewpointId);
 400             if(viewpoints == null) {
 401                 viewpoints = new ArrayList<ContributorBinding<ViewpointContributionFactory>>();
 402                 viewpointContributions.put(viewpointId, viewpoints);
 403             }
 404             viewpoints.add(binding);
 405         }
 406
 407         for(final ContributorBinding<ComparableContextFactory> binding : ComparableContextContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 408             comparableContextContributions.add(binding);
 409         }
 410
 411         for(final ContributorBinding<LabelerFactory> binding : LabelerContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 412             labelerContributions.add(binding);
 413         }
 414
 415         for(final ContributorBinding<CheckedStateFactory> binding : CheckedStateContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 416             checkStateContributions.add(binding);
 417         }
 418
 419         for(final ContributorBinding<LabelDecoratorFactory> binding : LabelDecoratorContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 420             labelDecoratorContributions.add(binding);
 421         }
 422
 423         for(final ContributorBinding<ImagerFactory> binding : ImagerContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 424             imagerContributions.add(binding);
 425         }
 426
 427         for(final ContributorBinding<ImageDecoratorFactory> binding : ImageDecoratorContributorBindingExtensionManager.getInstance().getBoundContributions(browseContexts)) {
 428             imageDecoratorContributions.add(binding);
 429         }
 430
 431     }
 432
 433     public static EvaluatorData load(RequestProcessor processor, Set<String> browseContexts, ResourceManager resourceManager) throws InvalidBrowserIdException {
 434         return load(processor, browseContexts, resourceManager, false, false);
 435     }
 436
 437     public static EvaluatorData load(RequestProcessor processor, Set<String> browseContexts, ResourceManager resourceManager, boolean useNodeBrowseContexts, boolean useNodeActionContexts) throws InvalidBrowserIdException {
 438
 439         Map<String, Collection<ContributorBinding<ViewpointContributionFactory>>> viewpointContributions = new HashMap<String, Collection<ContributorBinding<ViewpointContributionFactory>>>();
 440         Set<ContributorBinding<ComparableContextFactory>> comparableContextContributions = new HashSet<ContributorBinding<ComparableContextFactory>>();
 441         Set<ContributorBinding<LabelerFactory>> labelerContributions = new HashSet<ContributorBinding<LabelerFactory>>();
 442         Set<ContributorBinding<CheckedStateFactory>> checkStateContributions = new HashSet<ContributorBinding<CheckedStateFactory>>();
 443         Set<ContributorBinding<LabelDecoratorFactory>> labelDecoratorContributions = new HashSet<ContributorBinding<LabelDecoratorFactory>>();
 444         Set<ContributorBinding<ImagerFactory>> imagerContributions = new HashSet<ContributorBinding<ImagerFactory>>();
 445         Set<ContributorBinding<ImageDecoratorFactory>> imageDecoratorContributions = new HashSet<ContributorBinding<ImageDecoratorFactory>>();
 446
 447         EvaluatorDataImpl data = new EvaluatorDataImpl();
 448
 449         // Load modelled contributions
 450         Set<String> allBrowseContexts = loadModelled(processor, browseContexts, resourceManager, data, useNodeBrowseContexts, useNodeActionContexts);
 451
 452         // Load extension point contributions
 453         loadExtensions(processor, allBrowseContexts, resourceManager, viewpointContributions, comparableContextContributions, labelerContributions, checkStateContributions, labelDecoratorContributions, imagerContributions, imageDecoratorContributions);
 454
 455         // Create contributed evaluators
 456         create(data, resourceManager, viewpointContributions, comparableContextContributions, labelerContributions, checkStateContributions, labelDecoratorContributions, imagerContributions, imageDecoratorContributions);
 457
 458         // Create plugin evaluators for the contexts
 459         for(EvaluatorFactory factory : EvaluatorBindingExtensionManager.getInstance().getBoundFactories(allBrowseContexts)) {
 460             data.addEvaluator(factory.getClazz(), factory.create(allBrowseContexts));
 461         }
 462
 463         return data;
 464
 465     }
 466
 467 }