/*
   * (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;
  }
 public static boolean processAddition(
     final MToolBar toolBarModel,
     MToolBarContribution toolBarContribution,
     List<MToolBarElement> contributions,
     HashSet<String> existingSeparatorNames) {
   int idx = getIndex(toolBarModel, toolBarContribution.getPositionInParent());
   if (idx == -1) {
     return false;
   }
   for (MToolBarElement item : toolBarContribution.getChildren()) {
     if (item instanceof MToolBarSeparator
         && existingSeparatorNames.contains(item.getElementId())) {
       // skip this, it's already there
       continue;
     }
     MToolBarElement copy = (MToolBarElement) EcoreUtil.copy((EObject) item);
     if (DEBUG) {
       trace(
           "addToolBarContribution " + copy,
           toolBarModel.getWidget(),
           toolBarModel); //$NON-NLS-1$
     }
     toolBarModel.getChildren().add(idx++, copy);
     contributions.add(copy);
     if (copy instanceof MToolBarSeparator && copy.getElementId() != null) {
       existingSeparatorNames.add(copy.getElementId());
     }
   }
   return true;
 }
 /*
  * (non-Javadoc)
  *
  * @see
  * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#postProcess
  * (org.eclipse.e4.ui.model.application.ui.MUIElement)
  */
 @Override
 public void postProcess(MUIElement element) {
   if (element instanceof MToolBar) {
     MToolBar toolbarModel = (MToolBar) element;
     if (toolbarModel.getTransientData().containsKey(POST_PROCESSING_FUNCTION)) {
       Object obj = toolbarModel.getTransientData().get(POST_PROCESSING_FUNCTION);
       if (obj instanceof IContextFunction) {
         IContextFunction func = (IContextFunction) obj;
         final IEclipseContext ctx = getContext(toolbarModel);
         toolbarModel.getTransientData().put(POST_PROCESSING_DISPOSE, func.compute(ctx, null));
       }
     }
   }
 }
 @Override
 public void processContents(MElementContainer<MUIElement> container) {
   super.processContents(container);
   IEclipseContext ctx = getContext(container);
   ExpressionContext eContext = new ExpressionContext(ctx);
   ArrayList<MToolBarContribution> toContribute = new ArrayList<MToolBarContribution>();
   MElementContainer<?> toolbarObj = container;
   MToolBar toolbarModel = (MToolBar) toolbarObj;
   ContributionsAnalyzer.gatherToolBarContributions(
       toolbarModel,
       application.getToolBarContributions(),
       toolbarModel.getElementId(),
       toContribute,
       eContext);
   addToolBarContributions(toolbarModel, toContribute, ctx, eContext, pendingCleanup);
 }
  public static void addToolBarContributions(
      final MToolBar toolbarModel,
      ArrayList<MToolBarContribution> toContribute,
      IEclipseContext ctx,
      final ExpressionContext eContext,
      HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>> pendingCleanup) {
    HashSet<String> existingSeparatorNames = new HashSet<String>();
    for (MToolBarElement child : toolbarModel.getChildren()) {
      String elementId = child.getElementId();
      if (child instanceof MToolBarSeparator && elementId != null) {
        existingSeparatorNames.add(elementId);
      }
    }
    boolean done = toContribute.size() == 0;
    while (!done) {
      ArrayList<MToolBarContribution> curList = new ArrayList<MToolBarContribution>(toContribute);
      int retryCount = toContribute.size();
      toContribute.clear();

      for (final MToolBarContribution contribution : curList) {
        final ArrayList<MToolBarElement> toRemove = new ArrayList<MToolBarElement>();
        if (!ContributionsAnalyzer.processAddition(
            toolbarModel, contribution, toRemove, existingSeparatorNames)) {
          toContribute.add(contribution);
        } else {
          if (contribution.getVisibleWhen() != null) {
            ctx.runAndTrack(
                new RunAndTrack() {
                  @Override
                  public boolean changed(IEclipseContext context) {
                    if (!toolbarModel.isToBeRendered()
                        || !toolbarModel.isVisible()
                        || toolbarModel.getWidget() == null) {
                      return false;
                    }
                    boolean rc = ContributionsAnalyzer.isVisible(contribution, eContext);
                    for (MToolBarElement child : toRemove) {
                      child.setToBeRendered(rc);
                    }
                    return true;
                  }
                });
          }
          ArrayList<ArrayList<MToolBarElement>> lists = pendingCleanup.get(toolbarModel);
          if (lists == null) {
            lists = new ArrayList<ArrayList<MToolBarElement>>();
            pendingCleanup.put(toolbarModel, lists);
          }
          lists.add(toRemove);
        }
      }
      // We're done if the retryList is now empty (everything done) or
      // if the list hasn't changed at all (no hope)
      done = (toContribute.size() == 0) || (toContribute.size() == retryCount);
    }
  }
  @Override
  public void disposeWidget(MUIElement element) {
    if (element instanceof MPart) {
      MPart part = (MPart) element;
      MToolBar toolBar = part.getToolbar();
      if (toolBar != null) {
        Widget widget = (Widget) toolBar.getWidget();
        if (widget != null) {
          unbindWidget(toolBar);
          widget.dispose();
        }
      }

      for (MMenu menu : part.getMenus()) {
        engine.removeGui(menu);
      }
    }
    super.disposeWidget(element);
  }
Пример #7
0
  private void restorePersistedState(MApplication application, MPart part) {

    final Map<String, String> persistedState = application.getPersistedState();
    showSuppressedLines =
        toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_SUPPRESS_LINES));
    showGrblStateLines =
        toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_GRBL_STATE));
    showGcodeModeLines =
        toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_GRBL_MODES));

    // set the state of the direct menu items according to persisted state
    // find the two direct menu items
    final MToolBar toolbar = part.getToolbar();
    List<MToolBarElement> toolBarChildren = toolbar.getChildren();
    for (MToolBarElement child : toolBarChildren) {
      if (child instanceof MHandledToolItem
          && child
              .getElementId()
              .equals("de.jungierek.grblrunner.handledtoolitem.terminal.togglesuppresslines")) {
        LOG.debug(
            "restorePersistedState: child=" + child.getElementId() + " class=" + child.getClass());
        MMenu menu = ((MHandledToolItem) child).getMenu();
        if (menu != null) {
          List<MMenuElement> items = menu.getChildren();
          for (MMenuElement item : items) {
            LOG.debug(
                "restorePersistedState: item=" + item.getElementId() + "class=" + child.getClass());
            switch (item.getElementId()) {
              case "de.jungierek.grblrunner.directmenuitem.togglesuppresslines.grblstate":
                ((MMenuItem) item).setSelected(showGrblStateLines);
                break;
              case "de.jungierek.grblrunner.directmenuitem.togglesuppresslines.gcodestate":
                ((MMenuItem) item).setSelected(showGcodeModeLines);
                break;
              default:
                break;
            }
          }
        }
      }
    }
  }
 protected void cleanUp(MToolBar element) {
   ArrayList<ArrayList<MToolBarElement>> lists = pendingCleanup.remove(element);
   if (lists == null) {
     return;
   }
   for (ArrayList<MToolBarElement> list : lists) {
     for (MToolBarElement child : list) {
       element.getChildren().remove(child);
     }
   }
 }
 private IEclipseContext getStaticContext() {
   if (infoContext == null) {
     IEclipseContext parentContext = renderer.getContext(toolbarModel);
     if (parentContext != null) {
       infoContext = parentContext.createChild(STATIC_CONTEXT);
     } else {
       infoContext = EclipseContextFactory.create(STATIC_CONTEXT);
     }
     ContributionsAnalyzer.populateModelInterfaces(
         toolbarModel, infoContext, toolbarModel.getClass().getInterfaces());
     infoContext.set(ToolBarRenderer.class, renderer);
   }
   return infoContext;
 }
  public void reconcileManagerToModel(IToolBarManager menuManager, MToolBar toolBar) {
    List<MToolBarElement> modelChildren = toolBar.getChildren();
    HashSet<MOpaqueToolItem> oldModelItems = new HashSet<MOpaqueToolItem>();
    for (MToolBarElement itemModel : modelChildren) {
      if (itemModel instanceof MOpaqueToolItem) {
        oldModelItems.add((MOpaqueToolItem) itemModel);
      }
    }

    IContributionItem[] items = menuManager.getItems();
    for (int src = 0, dest = 0; src < items.length; src++, dest++) {
      IContributionItem item = items[src];
      MToolBarElement element = getToolElement(item);
      if (element == null) {
        MOpaqueToolItem legacyItem = MenuFactoryImpl.eINSTANCE.createOpaqueToolItem();
        legacyItem.setElementId(item.getId());
        legacyItem.setVisible(item.isVisible());
        legacyItem.setOpaqueItem(item);
        linkModelToContribution(legacyItem, item);
        modelChildren.add(dest, legacyItem);
      } else if (element instanceof MOpaqueToolItem) {
        MOpaqueToolItem legacyItem = (MOpaqueToolItem) element;
        oldModelItems.remove(legacyItem);
        if (modelChildren.size() > dest) {
          if (modelChildren.get(dest) != legacyItem) {
            modelChildren.remove(legacyItem);
            modelChildren.add(dest, legacyItem);
          }
        } else {
          modelChildren.add(legacyItem);
        }
      }
    }

    if (!oldModelItems.isEmpty()) {
      modelChildren.removeAll(oldModelItems);
      for (MOpaqueToolItem model : oldModelItems) {
        clearModelToContribution(model, (IContributionItem) model.getOpaqueItem());
      }
    }
  }
  public boolean mergeIntoModel() {
    int idx = getIndex(toolbarModel, toolbarContribution.getPositionInParent());
    if (idx == -1) {
      return false;
    }

    final List<MToolBarElement> copyElements = new ArrayList<MToolBarElement>();
    for (MToolBarElement item : toolbarContribution.getChildren()) {
      MToolBarElement copy = (MToolBarElement) EcoreUtil.copy((EObject) item);
      copyElements.add(copy);
    }

    for (MToolBarElement copy : copyElements) {
      // if a visibleWhen clause is defined, the item should not be
      // visible until the clause has been evaluated and returned 'true'
      copy.setVisible(!anyVisibleWhen());
      generatedElements.add(copy);
      toolbarModel.getChildren().add(idx++, copy);
    }
    return true;
  }