@Override
  public Object compute(IEclipseContext context, String contextKey) {
    // look for the top-most MWindow in the context chain:

    // 1st: go up the tree to find topmost MWindow
    MWindow window = null;
    IEclipseContext current = context;
    do {
      MContext model = current.get(MContext.class);
      if (model instanceof MWindow) window = (MWindow) model;
      current = current.getParent();
    } while (current != null);

    if (window == null) {
      if (context.get(MApplication.class) != null) {
        // called from Application scope
        return ContextInjectionFactory.make(ApplicationPartServiceImpl.class, context);
      }
      return IInjector.NOT_A_VALUE;
    }

    IEclipseContext windowContext = window.getContext();
    PartServiceImpl service = windowContext.getLocal(PartServiceImpl.class);
    if (service == null) {
      service = ContextInjectionFactory.make(PartServiceImpl.class, windowContext);
      windowContext.set(PartServiceImpl.class, service);
    }
    return service;
  }
Beispiel #2
0
  public static void createParts(
      MApplication application, EModelService service, EPartService partService) {
    // Sometimes, when switching windows at startup, the active context
    // is null or doesn't have a window, and the part instantiation fails.
    // Ensure that a child context with a window is activated:
    IEclipseContext activeChild = application.getContext().getActiveChild();
    if (activeChild == null || activeChild.get(MTrimmedWindow.class) == null) {
      boolean activated = false;
      if (application.getContext() instanceof EclipseContext) {
        for (IEclipseContext child : ((EclipseContext) application.getContext()).getChildren()) {
          MTrimmedWindow window = child.get(MTrimmedWindow.class);
          if (window != null) {
            child.activate();
            activated = true;
            break;
          }
        }
      }
      if (!activated) {
        logger.error("Could not activate window for part instantiation"); // $NON-NLS-1$
        return;
      }
    }

    List<MPart> ontops = new ArrayList<MPart>();
    for (MPartDescriptor descriptor : application.getDescriptors()) {
      if (!(descriptor.getPersistedState().containsKey(VISIBLE_ID)
          && Boolean.toString(true)
              .equalsIgnoreCase(descriptor.getPersistedState().get(VISIBLE_ID)))) {
        continue;
      }
      List<MPart> existingParts =
          service.findElements(application, descriptor.getElementId(), MPart.class, null);
      if (!existingParts.isEmpty()) {
        // part is already instantiated
        continue;
      }
      MPart part = partService.createPart(descriptor.getElementId());
      if (part == null) {
        continue;
      }
      addPartToAppropriateContainer(part, descriptor, application, service);
      partService.activate(part);
      if (descriptor.getPersistedState().containsKey(ONTOP_ID)
          && Boolean.toString(true)
              .equalsIgnoreCase(descriptor.getPersistedState().get(ONTOP_ID))) {
        ontops.add(part);
      }
    }

    // reactivate ontop parts to ensure they are on-top
    for (MPart ontop : ontops) {
      partService.activate(ontop);
    }
  }
  /**
   * This is a singleton service. One instance is used throughout the running application
   *
   * @param appContext The applicationContext to get the eventBroker from
   * @throws NullPointerException if the given appContext is <code>null</code>
   */
  public ModelServiceImpl(IEclipseContext appContext) {
    if (appContext == null) {
      throw new NullPointerException("No application context given!"); // $NON-NLS-1$
    }

    this.appContext = appContext;
    IEventBroker eventBroker = appContext.get(IEventBroker.class);
    eventBroker.subscribe(UIEvents.UIElement.TOPIC_WIDGET, hostedElementHandler);

    mApplicationElementFactory =
        new GenericMApplicationElementFactoryImpl(appContext.get(IExtensionRegistry.class));
  }
 @Inject
 public void injectedMethod(
     @Named("arg1") String strValue, @Named("arg2") Integer intValue, IEclipseContext context) {
   string = strValue;
   integer = intValue;
   if (context == null) {
     other = null;
     return;
   }
   IEclipseContext otherContext = (IEclipseContext) context.get("otherContext");
   if (otherContext == null) {
     other = null;
   } else {
     other = (String) otherContext.get("arg3");
   }
 }
  private void cleanUpContributionCache() {
    if (!actionContributionCache.isEmpty()) {
      PluginActionContributionItem[] items =
          actionContributionCache.toArray(
              new PluginActionContributionItem[actionContributionCache.size()]);
      actionContributionCache.clear();
      for (int i = 0; i < items.length; i++) {
        items[i].dispose();
      }
    }

    if (modelPart == null || menuModel == null) {
      return;
    }
    IEclipseContext modelContext = modelPart.getContext();
    if (modelContext != null) {
      IRendererFactory factory = modelContext.get(IRendererFactory.class);
      if (factory != null) {
        AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
        if (obj instanceof MenuManagerRenderer) {
          MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
          renderer.cleanUp(menuModel);
        }
      }
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see
   * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget
   * (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object)
   */
  @Override
  public Object createWidget(final MUIElement element, Object parent) {
    if (!(element instanceof MToolBar) || !(parent instanceof Composite)) return null;

    final MToolBar toolbarModel = (MToolBar) element;
    ToolBar newTB = createToolbar(toolbarModel, (Composite) parent);
    bindWidget(element, newTB);
    processContribution(toolbarModel, toolbarModel.getElementId());

    Control renderedCtrl = newTB;
    MUIElement parentElement = element.getParent();
    if (parentElement instanceof MTrimBar) {
      element.getTags().add("Draggable"); // $NON-NLS-1$

      setCSSInfo(element, newTB);

      boolean vertical = false;
      MTrimBar bar = (MTrimBar) parentElement;
      vertical = bar.getSide() == SideValue.LEFT || bar.getSide() == SideValue.RIGHT;
      IEclipseContext parentContext = getContextForParent(element);
      CSSRenderingUtils cssUtils = parentContext.get(CSSRenderingUtils.class);
      if (cssUtils != null) {
        renderedCtrl = (Composite) cssUtils.frameMeIfPossible(newTB, null, vertical, true);
      }
    }

    return renderedCtrl;
  }
 @Override
 public void initialize(String nodeID, IEclipseContext context) {
   alternative = (InputAlternative) context.get(IEditorInputResource.class);
   if (alternative != null) {
     alternative.addPropertyChangeListener(projectListener);
   }
 }
Beispiel #8
0
  private void generateGcodeProgram() {

    LOG.debug("generateGcodeProgram:");

    gcodeProgram.clear();

    gcodeProgram.appendLine("(Macro for " + getTitle() + ")");
    gcodeProgram.appendLine("(generated " + getTimestamp() + ")");
    gcodeProgram.appendLine("G21");
    gcodeProgram.appendLine("G90");

    generateGcodeCore(gcodeProgram);

    if (gcodeGenerationError) {

      clear();

    } else {

      gcodeProgram.appendLine(
          "G0 Z"
              + String.format(
                  IConstant.FORMAT_COORDINATE, getDoublePreference(IPreferenceKey.Z_CLEARANCE)));
      gcodeProgram.appendLine("M5");

      gcodeProgram.parse();

      Text gcodeText = (Text) context.get(IConstant.MACRO_TEXT_ID);
      if (gcodeText != null) toolbox.gcodeToText(gcodeText, gcodeProgram);
    }

    eventBroker.send(IEvent.GCODE_MACRO_GENERATED, null);
    eventBroker.send(IEvent.REDRAW, null);
  }
  /**
   * Simplified copy of IDEAplication processing that does not offer to choose a workspace location.
   */
  private boolean checkInstanceLocation(
      Location instanceLocation, Shell shell, IEclipseContext context) {

    // Eclipse has been run with -data @none or -data @noDefault options so
    // we don't need to validate the location
    if (instanceLocation == null && Boolean.FALSE.equals(context.get(IWorkbench.PERSIST_STATE))) {
      return true;
    }

    if (instanceLocation == null) {
      MessageDialog.openError(
          shell,
          WorkbenchSWTMessages.IDEApplication_workspaceMandatoryTitle,
          WorkbenchSWTMessages.IDEApplication_workspaceMandatoryMessage);
      return false;
    }

    // -data "/valid/path", workspace already set
    if (instanceLocation.isSet()) {
      // make sure the meta data version is compatible (or the user
      // has
      // chosen to overwrite it).
      if (!checkValidWorkspace(shell, instanceLocation.getURL())) {
        return false;
      }

      // at this point its valid, so try to lock it and update the
      // metadata version information if successful
      try {
        if (instanceLocation.lock()) {
          writeWorkspaceVersion();
          return true;
        }

        // we failed to create the directory.
        // Two possibilities:
        // 1. directory is already in use
        // 2. directory could not be created
        File workspaceDirectory = new File(instanceLocation.getURL().getFile());
        if (workspaceDirectory.exists()) {
          MessageDialog.openError(
              shell,
              WorkbenchSWTMessages.IDEApplication_workspaceCannotLockTitle,
              WorkbenchSWTMessages.IDEApplication_workspaceCannotLockMessage);
        } else {
          MessageDialog.openError(
              shell,
              WorkbenchSWTMessages.IDEApplication_workspaceCannotBeSetTitle,
              WorkbenchSWTMessages.IDEApplication_workspaceCannotBeSetMessage);
        }
      } catch (IOException e) {
        Logger logger = new WorkbenchLogger(PLUGIN_ID);
        logger.error(e);
        MessageDialog.openError(shell, WorkbenchSWTMessages.InternalError, e.getMessage());
      }
      return false;
    }
    return false;
  }
 private void fillArgs(Object[] actualArgs, String[] keys, boolean[] active) {
   for (int i = 0; i < keys.length; i++) {
     if (keys[i] == null) continue;
     IEclipseContext targetContext = (active[i]) ? context.getActiveLeaf() : context;
     if (ECLIPSE_CONTEXT_NAME.equals(keys[i])) actualArgs[i] = targetContext;
     else if (targetContext.containsKey(keys[i])) actualArgs[i] = targetContext.get(keys[i]);
   }
 }
 private ImageDescriptor getImageDescriptor(MUILabel element) {
   IEclipseContext localContext = context;
   String iconURI = element.getIconURI();
   if (iconURI != null && iconURI.length() > 0) {
     ISWTResourceUtilities resUtils =
         (ISWTResourceUtilities) localContext.get(IResourceUtilities.class.getName());
     return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
   }
   return null;
 }
  public void testCreateWindow() {
    final MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
    window.setLabel("MyWindow");
    wb = new E4Workbench(window, appContext);

    Widget topWidget = (Widget) window.getWidget();
    assertTrue(topWidget instanceof Shell);
    assertEquals("MyWindow", ((Shell) topWidget).getText());
    assertEquals(topWidget, appContext.get(IServiceConstants.ACTIVE_SHELL));
  }
  /**
   * Check if this Handler is enabled on the selection. Only one Teststrucutre is valid as a
   * selection.
   *
   * @param context Eclipse Context to retrive the Viewer
   * @return true if only one element is selected.
   */
  @CanExecute
  public boolean canExecute(IEclipseContext context) {

    TestExplorer explorer = (TestExplorer) context.get(TestEditorConstants.TEST_EXPLORER_VIEW);
    TestStructure selected = (TestStructure) explorer.getSelection().getFirstElement();

    renameHandler = getAbstactRenameTestStructureHandler(context, selected);
    if (renameHandler != null) {
      return renameHandler.canExecute(context);
    }
    return false;
  }
 private void simulateMenuSelection(MMenuItem item) {
   // FIXME: pity this code isn't available through the MMenuItem instance
   // somehow
   IEclipseContext lclContext = getContext(item);
   if (item instanceof MDirectMenuItem) {
     MDirectMenuItem dmi = (MDirectMenuItem) item;
     if (dmi.getObject() == null) {
       IContributionFactory cf =
           (IContributionFactory) lclContext.get(IContributionFactory.class.getName());
       dmi.setObject(cf.create(dmi.getContributionURI(), lclContext));
     }
     lclContext.set(MItem.class.getName(), item);
     ContextInjectionFactory.invoke(dmi.getObject(), Execute.class, lclContext);
     lclContext.remove(MItem.class.getName());
   } else if (item instanceof MHandledMenuItem) {
     MHandledMenuItem hmi = (MHandledMenuItem) item;
     EHandlerService service = (EHandlerService) lclContext.get(EHandlerService.class.getName());
     ParameterizedCommand cmd = hmi.getWbCommand();
     if (cmd == null) {
       cmd = HandledMenuItemRenderer.generateParameterizedCommand(hmi, lclContext);
     }
     lclContext.set(MItem.class.getName(), item);
     service.executeHandler(cmd);
     lclContext.remove(MItem.class.getName());
   } else {
     statusReporter
         .get()
         .report(
             new Status(
                 IStatus.WARNING,
                 CocoaUIProcessor.FRAGMENT_ID,
                 "Unhandled menu type: "
                     + item.getClass()
                     + ": "
                     + item), //$NON-NLS-1$ //$NON-NLS-2$ $NON-NLS-2$
             StatusReporter.LOG);
   }
 }
    @Override
    public boolean update(IEclipseContext eventsContext, int eventType, Object[] extraArguments) {
      if (eventType == ContextChangeEvent.INITIAL) {
        // needs to be done inside runnable to establish dependencies
        for (int i = 0; i < keys.length; i++) {
          if (keys[i] == null) continue;
          IEclipseContext targetContext = (active[i]) ? context.getActiveLeaf() : context;
          if (ECLIPSE_CONTEXT_NAME.equals(keys[i])) {
            result[i] = targetContext;
            IEclipseContext parent = targetContext.getParent(); // creates pseudo-link
            if (parent == null)
              targetContext.get(ECLIPSE_CONTEXT_NAME); // pseudo-link in case there is no parent
          } else if (targetContext.containsKey(keys[i])) result[i] = targetContext.get(keys[i]);
        }
        return true;
      }

      if (eventType == ContextChangeEvent.DISPOSE) {
        if (eventsContext == context) {
          ContextObjectSupplier originatingSupplier =
              eventsContext.getLocal(ContextObjectSupplier.class);
          requestor.disposed(originatingSupplier);
          return false;
        }
      } else if (eventType == ContextChangeEvent.UNINJECTED) {
        if (eventsContext == context) {
          ContextObjectSupplier originatingSupplier =
              eventsContext.getLocal(ContextObjectSupplier.class);
          return requestor.uninject(extraArguments[0], originatingSupplier);
        }
      } else {
        if (!requestor.isValid()) return false; // remove this listener
        requestor.resolveArguments(false);
        requestor.execute();
      }
      return true;
    }
  @Override
  public MPartDescriptor getPartDescriptor(String id) {
    MApplication application = appContext.get(MApplication.class);

    // If the id contains a ':' use the part before it as the descriptor id
    int colonIndex = id == null ? -1 : id.indexOf(':');
    String descId = colonIndex == -1 ? id : id.substring(0, colonIndex);

    for (MPartDescriptor descriptor : application.getDescriptors()) {
      if (descriptor.getElementId().equals(descId)) {
        return descriptor;
      }
    }
    return null;
  }
 public static ParameterizedCommand generateParameterizedCommand(
     final MHandledItem item, final IEclipseContext lclContext) {
   ECommandService cmdService = (ECommandService) lclContext.get(ECommandService.class.getName());
   Map<String, Object> parameters = null;
   List<MParameter> modelParms = item.getParameters();
   if (modelParms != null && !modelParms.isEmpty()) {
     parameters = new HashMap<String, Object>();
     for (MParameter mParm : modelParms) {
       parameters.put(mParm.getName(), mParm.getValue());
     }
   }
   ParameterizedCommand cmd =
       cmdService.createCommand(item.getCommand().getElementId(), parameters);
   item.setWbCommand(cmd);
   return cmd;
 }
  @Override
  protected void createFieldEditors() {
    // TODO Auto-generated method stub
    Composite container = (Composite) this.getControl();

    addField(
        new BooleanFieldEditor(
            BTSCorpusConstants.PREF_LEMMA_NAVIGATOR_SORTBYKEY,
            "Lemma Navigator sort by sort key",
            BooleanFieldEditor.DEFAULT,
            getFieldEditorParent()));
    context = StaticAccessController.getContext();
    configurationController = context.get(PassportConfigurationController.class);

    Label lblVisibility = new Label(container, SWT.NONE);
    lblVisibility.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 1));
    lblVisibility.setText("Default Visibility");

    visibilityCMB_Admin = new Combo(container, SWT.READ_ONLY);
    visibilityCMB_Admin.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, true, false, 3, 1));
    visibility_viewer = new ComboViewer(visibilityCMB_Admin);
    AdapterFactoryLabelProvider labelProvider_vis = new AdapterFactoryLabelProvider(factory);
    AdapterFactoryContentProvider contentProvider_vis = new AdapterFactoryContentProvider(factory);

    visibility_viewer.setContentProvider(contentProvider_vis);
    visibility_viewer.setLabelProvider(labelProvider_vis);
    visibility_viewer.setInput(
        configurationController.getVisibilityConfigItemProcessedClones(null));

    Label lblRevisionState = new Label(container, SWT.NONE);
    lblRevisionState.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 1));
    lblRevisionState.setText("Default Review State");

    reviewCMB_Admin = new Combo(container, SWT.READ_ONLY);
    reviewCMB_Admin.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, true, false, 3, 1));
    reviewState_viewer = new ComboViewer(reviewCMB_Admin);

    AdapterFactoryLabelProvider labelProvider_rev = new AdapterFactoryLabelProvider(factory);
    AdapterFactoryContentProvider contentProvider_rev = new AdapterFactoryContentProvider(factory);

    reviewState_viewer.setContentProvider(contentProvider_rev);
    reviewState_viewer.setLabelProvider(labelProvider_rev);
    reviewState_viewer.setInput(
        configurationController.getReviewStateConfigItemProcessedClones(null));
    init();
    container.layout();
  }
  private IGcodeProgram getSelectedProgram(String text) {

    LOG.debug("getSelectedProgram: text=" + text);

    Collection<MPart> parts = partService.getParts();
    for (MPart part : parts) {
      if (isOverlayPart(part)) {
        if (text.equals(part.getLabel())) {
          final IEclipseContext context = part.getContext();
          if (context != null) return context.get(IGcodeProgram.class);
        }
      }
    }

    // if part is not instantiated and therefore gcode program is not loaded, then we are here
    return null;
  }
  private MApplication loadApplicationModel(
      IApplicationContext appContext, IEclipseContext eclipseContext) {
    MApplication theApp = null;

    Location instanceLocation = WorkbenchSWTActivator.getDefault().getInstanceLocation();

    URI applicationModelURI = determineApplicationModelURI(appContext);
    eclipseContext.set(E4Workbench.INITIAL_WORKBENCH_MODEL_URI, applicationModelURI);

    // Save and restore
    Boolean saveAndRestore =
        getArgValue(IWorkbench.PERSIST_STATE, appContext, false)
            .map(value -> Boolean.parseBoolean(value))
            .orElse(Boolean.TRUE);

    eclipseContext.set(IWorkbench.PERSIST_STATE, saveAndRestore);

    // when -data @none or -data @noDefault options
    if (instanceLocation != null && instanceLocation.getURL() != null) {
      eclipseContext.set(E4Workbench.INSTANCE_LOCATION, instanceLocation);
    } else {
      eclipseContext.set(IWorkbench.PERSIST_STATE, false);
    }

    // Persisted state
    Boolean clearPersistedState =
        getArgValue(IWorkbench.CLEAR_PERSISTED_STATE, appContext, true)
            .map(value -> Boolean.parseBoolean(value))
            .orElse(Boolean.FALSE);
    eclipseContext.set(IWorkbench.CLEAR_PERSISTED_STATE, clearPersistedState);

    String resourceHandler =
        getArgValue(IWorkbench.MODEL_RESOURCE_HANDLER, appContext, false)
            .orElse("bundleclass://org.eclipse.e4.ui.workbench/" + ResourceHandler.class.getName());

    IContributionFactory factory = eclipseContext.get(IContributionFactory.class);

    handler = (IModelResourceHandler) factory.create(resourceHandler, eclipseContext);
    eclipseContext.set(IModelResourceHandler.class, handler);

    Resource resource = handler.loadMostRecentModel();
    theApp = (MApplication) resource.getContents().get(0);

    return theApp;
  }
  private void setEnabled(MHandledMenuItem itemModel, MenuItem newItem) {
    ParameterizedCommand cmd = itemModel.getWbCommand();
    if (cmd == null) {
      return;
    }
    final IEclipseContext lclContext = getContext(itemModel);
    EHandlerService service = lclContext.get(EHandlerService.class);
    final IEclipseContext staticContext = EclipseContextFactory.create(HMI_STATIC_CONTEXT);
    ContributionsAnalyzer.populateModelInterfaces(
        itemModel, staticContext, itemModel.getClass().getInterfaces());

    try {
      itemModel.setEnabled(service.canExecute(cmd, staticContext));
    } finally {
      staticContext.dispose();
    }
    newItem.setEnabled(itemModel.isEnabled());
  }
  @Test
  public void testU() throws Exception {
    IEclipseContext parentContext = EclipseContextFactory.create();
    parentContext.set("aString", "");
    parentContext.set(MyTest.class.getName(), new TestFunction());
    IEclipseContext context = parentContext.createChild();

    MyTest test = (MyTest) context.get(MyTest.class.getName());

    assertEquals(0, test.getCount());
    context.dispose();
    assertEquals("Context disposed, @PreDestroy should've been called", 1, test.getCount());
    parentContext.dispose();
    assertEquals(
        "Parent context disposed, @PreDestroy should not have been called again",
        1,
        test.getCount());
  }
  /**
   * Initialize a part renderer from the extension point.
   *
   * @param context the context for the part factories
   */
  @PostConstruct
  void initialize(IEclipseContext context) {
    this.appContext = context;

    // initialize the correct key-binding display formatter
    KeyFormatterFactory.setDefault(SWTKeySupport.getKeyFormatterForPlatform());

    // Add the renderer to the context
    context.set(IPresentationEngine.class.getName(), this);

    IRendererFactory factory = null;
    IContributionFactory contribFactory = context.get(IContributionFactory.class);
    try {
      factory = (IRendererFactory) contribFactory.create(factoryUrl, context);
    } catch (Exception e) {
      logger.warn(e, "Could not create rendering factory");
    }

    // Try to load the default one
    if (factory == null) {
      try {
        factory = (IRendererFactory) contribFactory.create(defaultFactoryUrl, context);
      } catch (Exception e) {
        logger.error(e, "Could not create default rendering factory");
      }
    }

    if (factory == null) {
      throw new IllegalStateException("Could not create any rendering factory. Aborting ...");
    }

    curFactory = factory;
    context.set(IRendererFactory.class, curFactory);

    // Hook up the widget life-cycle subscriber
    if (eventBroker != null) {
      eventBroker.subscribe(UIEvents.UIElement.TOPIC_TOBERENDERED, toBeRenderedHandler);
      eventBroker.subscribe(UIEvents.UIElement.TOPIC_VISIBLE, visibilityHandler);
      eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_CHILDREN, childrenHandler);
      eventBroker.subscribe(UIEvents.Window.TOPIC_WINDOWS, windowsHandler);
      eventBroker.subscribe(UIEvents.Perspective.TOPIC_WINDOWS, windowsHandler);
      eventBroker.subscribe(UIEvents.TrimmedWindow.TOPIC_TRIMBARS, trimHandler);
    }
  }
 private void handleNullRefPlaceHolders(MUIElement element, MWindow refWin, boolean resolve) {
   // use appContext as MApplication.getContext() is null during the processing of
   // the model processor classes
   EPlaceholderResolver resolver = appContext.get(EPlaceholderResolver.class);
   // Re-resolve any placeholder references
   List<MPlaceholder> phList = findElements(element, null, MPlaceholder.class, null);
   List<MPlaceholder> nullRefList = new ArrayList<>();
   for (MPlaceholder ph : phList) {
     if (resolve) {
       resolver.resolvePlaceholderRef(ph, refWin);
     }
     if (ph.getRef() == null) {
       nullRefList.add(ph);
     }
   }
   for (MPlaceholder ph : nullRefList) {
     replacePlaceholder(ph);
   }
   return;
 }
  // TODO This should go into a different bundle
  public static IEclipseContext createDefaultHeadlessContext() {
    IEclipseContext serviceContext = E4Workbench.getServiceContext();

    IExtensionRegistry registry = RegistryFactory.getRegistry();
    ExceptionHandler exceptionHandler = new ExceptionHandler();
    ReflectionContributionFactory contributionFactory = new ReflectionContributionFactory(registry);
    serviceContext.set(IContributionFactory.class, contributionFactory);
    serviceContext.set(IExceptionHandler.class, exceptionHandler);
    serviceContext.set(IExtensionRegistry.class, registry);

    serviceContext.set(
        Adapter.class, ContextInjectionFactory.make(EclipseAdapter.class, serviceContext));

    // No default log provider available
    if (serviceContext.get(ILoggerProvider.class) == null) {
      serviceContext.set(
          ILoggerProvider.class,
          ContextInjectionFactory.make(DefaultLoggerProvider.class, serviceContext));
    }

    return serviceContext;
  }
  public void testContextChildren() {
    final MWindow window = createWindowWithOneView();
    wb = new E4Workbench(window, appContext);

    Widget topWidget = (Widget) window.getWidget();
    assertTrue(topWidget instanceof Shell);
    Shell shell = (Shell) topWidget;
    assertEquals("MyWindow", shell.getText());

    // should get the window context
    IEclipseContext child = appContext.getActiveChild();
    assertNotNull(child);
    assertEquals(window.getContext(), child);

    MPart modelPart = getContributedPart(window);
    assertNotNull(modelPart);
    assertEquals(window, modelPart.getParent().getParent().getParent());

    // "activate" the part, same as (in theory) an
    // SWT.Activate event.
    AbstractPartRenderer factory = (AbstractPartRenderer) modelPart.getRenderer();
    factory.activate(modelPart);

    IEclipseContext next = child.getActiveChild();
    while (next != null) {
      child = next;
      next = child.getActiveChild();
      if (next == child) {
        fail("Cycle detected in part context");
        break;
      }
    }
    assertFalse(window.getContext() == child);

    MPart contextPart = (MPart) child.get(MPart.class.getName());

    assertNotNull(contextPart);
    assertEquals(window, contextPart.getParent().getParent().getParent());
  }
 protected void setItemText(MMenuItem model, MenuItem item) {
   String text = model.getLocalizedLabel();
   if (model instanceof MHandledItem) {
     MHandledItem handledItem = (MHandledItem) model;
     IEclipseContext context = getContext(model);
     EBindingService bs = (EBindingService) context.get(EBindingService.class.getName());
     ParameterizedCommand cmd = handledItem.getWbCommand();
     if (cmd != null && (text == null || text.length() == 0)) {
       try {
         text = cmd.getName();
       } catch (NotDefinedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
       }
     }
     TriggerSequence sequence = bs.getBestSequenceFor(handledItem.getWbCommand());
     if (sequence != null) {
       text = text + '\t' + sequence.format();
     }
     item.setText(text == null ? handledItem.getCommand().getElementId() : text);
   } else {
     super.setItemText(model, item);
   }
 }
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    parentContext =
        EclipseContextFactory.getServiceContext(CoreTestsActivator.getDefault().getBundleContext());
    context = parentContext.createChild(getName());

    // add some values to the contexts
    for (int i = 0; i < 100; i++) {
      context.set("Value-" + i, Integer.valueOf(i));
    }
    // do some additional service lookups on non-existent keys
    for (int i = 0; i < 1000; i++) {
      context.get("NonExistentValue-" + i);
    }

    // lookup some OSGi services
    context.get(DebugOptions.class.getName());
    context.get(IAdapterManager.class.getName());
    context.get(IExtensionRegistry.class.getName());
    context.get(IPreferencesService.class.getName());
    context.get(Location.class.getName());
  }
 private void warn(String message) {
   Logger logger = appContext.get(Logger.class);
   if (logger != null) {
     logger.warn(message);
   }
 }
  public E4Workbench createE4Workbench(
      IApplicationContext applicationContext, final Display display) {
    args = (String[]) applicationContext.getArguments().get(IApplicationContext.APPLICATION_ARGS);

    IEclipseContext appContext = createDefaultContext();
    appContext.set(Display.class, display);
    appContext.set(Realm.class, DisplayRealm.getRealm(display));
    appContext.set(
        UISynchronize.class,
        new UISynchronize() {

          @Override
          public void syncExec(Runnable runnable) {
            if (display != null && !display.isDisposed()) {
              display.syncExec(runnable);
            }
          }

          @Override
          public void asyncExec(Runnable runnable) {
            if (display != null && !display.isDisposed()) {
              display.asyncExec(runnable);
            }
          }
        });
    appContext.set(IApplicationContext.class, applicationContext);

    // This context will be used by the injector for its
    // extended data suppliers
    ContextInjectionFactory.setDefault(appContext);

    // Get the factory to create DI instances with
    IContributionFactory factory = appContext.get(IContributionFactory.class);

    // Install the life-cycle manager for this session if there's one
    // defined
    Optional<String> lifeCycleURI =
        getArgValue(IWorkbench.LIFE_CYCLE_URI_ARG, applicationContext, false);
    lifeCycleURI.ifPresent(
        lifeCycleURIValue -> {
          lcManager = factory.create(lifeCycleURIValue, appContext);
          if (lcManager != null) {
            // Let the manager manipulate the appContext if desired
            ContextInjectionFactory.invoke(lcManager, PostContextCreate.class, appContext, null);
          }
        });

    Optional<String> forcedPerspectiveId =
        getArgValue(PERSPECTIVE_ARG_NAME, applicationContext, false);
    forcedPerspectiveId.ifPresent(
        forcedPerspectiveIdValue ->
            appContext.set(E4Workbench.FORCED_PERSPECTIVE_ID, forcedPerspectiveIdValue));

    String showLocation = getLocationFromCommandLine();
    if (showLocation != null) {
      appContext.set(E4Workbench.FORCED_SHOW_LOCATION, showLocation);
    }

    // Create the app model and its context
    MApplication appModel = loadApplicationModel(applicationContext, appContext);
    appModel.setContext(appContext);

    boolean isRtl = ((Window.getDefaultOrientation() & SWT.RIGHT_TO_LEFT) != 0);
    appModel.getTransientData().put(E4Workbench.RTL_MODE, isRtl);

    // for compatibility layer: set the application in the OSGi service
    // context (see Workbench#getInstance())
    if (!E4Workbench.getServiceContext().containsKey(MApplication.class)) {
      // first one wins.
      E4Workbench.getServiceContext().set(MApplication.class, appModel);
    }

    // Set the app's context after adding itself
    appContext.set(MApplication.class, appModel);

    // adds basic services to the contexts
    initializeServices(appModel);

    // let the life cycle manager add to the model
    if (lcManager != null) {
      ContextInjectionFactory.invoke(lcManager, ProcessAdditions.class, appContext, null);
      ContextInjectionFactory.invoke(lcManager, ProcessRemovals.class, appContext, null);
    }

    // Create the addons
    IEclipseContext addonStaticContext = EclipseContextFactory.create();
    for (MAddon addon : appModel.getAddons()) {
      addonStaticContext.set(MAddon.class, addon);
      Object obj = factory.create(addon.getContributionURI(), appContext, addonStaticContext);
      addon.setObject(obj);
    }

    // Parse out parameters from both the command line and/or the product
    // definition (if any) and put them in the context
    Optional<String> xmiURI = getArgValue(IWorkbench.XMI_URI_ARG, applicationContext, false);
    xmiURI.ifPresent(
        xmiURIValue -> {
          appContext.set(IWorkbench.XMI_URI_ARG, xmiURIValue);
        });

    setCSSContextVariables(applicationContext, appContext);

    Optional<String> rendererFactoryURI =
        getArgValue(E4Workbench.RENDERER_FACTORY_URI, applicationContext, false);
    rendererFactoryURI.ifPresent(
        rendererFactoryURIValue -> {
          appContext.set(E4Workbench.RENDERER_FACTORY_URI, rendererFactoryURIValue);
        });

    // This is a default arg, if missing we use the default rendering engine
    Optional<String> presentationURI =
        getArgValue(IWorkbench.PRESENTATION_URI_ARG, applicationContext, false);
    appContext.set(
        IWorkbench.PRESENTATION_URI_ARG, presentationURI.orElse(PartRenderingEngine.engineURI));

    // Instantiate the Workbench (which is responsible for
    // 'running' the UI (if any)...
    return workbench = new E4Workbench(appModel, appContext);
  }