/**
  * Sets the visibility of the manager. If the visibility is <code>true</code> then each item
  * within the manager appears within the parent manager. Otherwise, the items are not visible.
  *
  * @param visible the new visibility
  */
 public void setVisible(boolean visible) {
   this.visible = visible;
   if (mapItemToWrapper.size() > 0) {
     Iterator<SubContributionItem> it = mapItemToWrapper.values().iterator();
     while (it.hasNext()) {
       IContributionItem item = it.next();
       item.setVisible(visible);
     }
     parentMgr.markDirty();
   }
 }
 /**
  * Disposes this sub contribution manager, removing all its items and cleaning up any other
  * resources allocated by it. This must leave no trace of this sub contribution manager in the
  * parent manager. Subclasses may extend.
  *
  * @since 3.0
  */
 public void disposeManager() {
   Iterator<SubContributionItem> it = mapItemToWrapper.values().iterator();
   // Dispose items in addition to removing them.
   // See bugs 64024 and 73715 for details.
   // Do not use getItems() here as subclasses can override that in bad ways.
   while (it.hasNext()) {
     IContributionItem item = it.next();
     item.dispose();
   }
   removeAll();
 }
Ejemplo n.º 3
0
 private boolean isChildVisible(IContributionItem item) {
   Boolean v = getOverrides().getVisible(item);
   if (v != null) {
     return v.booleanValue();
   }
   return item.isVisible();
 }
 /**
  * Notifies that an item has been removed.
  *
  * <p>Subclasses are not expected to override this method.
  *
  * @param item the item contributed by the client
  */
 protected void itemRemoved(IContributionItem item) {
   mapItemToWrapper.remove(item);
   item.setParent(null);
 }
 /**
  * Notifies that an item has been added.
  *
  * <p>Subclasses are not expected to override this method.
  *
  * @param item the item contributed by the client
  * @param wrap the item contributed to the parent manager as a proxy for the item contributed by
  *     the client
  */
 protected void itemAdded(IContributionItem item, SubContributionItem wrap) {
   item.setParent(this);
   mapItemToWrapper.put(item, wrap);
 }
Ejemplo n.º 6
0
  /**
   * Incrementally builds the menu from the contribution items. This method leaves out double
   * separators and separators in the first or last position.
   *
   * @param force <code>true</code> means update even if not dirty, and <code>false</code> for
   *     normal incremental updating
   * @param recursive <code>true</code> means recursively update all submenus, and <code>false
   *     </code> means just this menu
   */
  protected void update(boolean force, boolean recursive) {
    if (isDirty() || force) {
      if (menuExist()) {
        // clean contains all active items without double separators
        IContributionItem[] items = getItems();
        List clean = new ArrayList(items.length);
        IContributionItem separator = null;
        for (int i = 0; i < items.length; ++i) {
          IContributionItem ci = items[i];
          if (!isChildVisible(ci)) {
            continue;
          }
          if (ci.isSeparator()) {
            // delay creation until necessary
            // (handles both adjacent separators, and separator at end)
            separator = ci;
          } else {
            if (separator != null) {
              if (clean.size() > 0) {
                clean.add(separator);
              }
              separator = null;
            }
            clean.add(ci);
          }
        }

        // remove obsolete (removed or non active)
        Item[] mi = getMenuItems();

        for (int i = 0; i < mi.length; i++) {
          Object data = mi[i].getData();

          if (data == null || !clean.contains(data)) {
            mi[i].dispose();
          } else if (data instanceof IContributionItem
              && ((IContributionItem) data).isDynamic()
              && ((IContributionItem) data).isDirty()) {
            mi[i].dispose();
          }
        }

        // add new
        mi = getMenuItems();
        int srcIx = 0;
        int destIx = 0;

        for (Iterator e = clean.iterator(); e.hasNext(); ) {
          IContributionItem src = (IContributionItem) e.next();
          IContributionItem dest;

          // get corresponding item in SWT widget
          if (srcIx < mi.length) {
            dest = (IContributionItem) mi[srcIx].getData();
          } else {
            dest = null;
          }

          if (dest != null && src.equals(dest)) {
            srcIx++;
            destIx++;
          } else if (dest != null && dest.isSeparator() && src.isSeparator()) {
            mi[srcIx].setData(src);
            srcIx++;
            destIx++;
          } else {
            int start = getMenuItemCount();
            doItemFill(src, destIx);
            int newItems = getMenuItemCount() - start;
            for (int i = 0; i < newItems; i++) {
              Item item = getMenuItem(destIx++);
              item.setData(src);
            }
          }

          // May be we can optimize this call. If the menu has just
          // been created via the call src.fill(fMenuBar, destIx) then
          // the menu has already been updated with update(true)
          // (see MenuManager). So if force is true we do it again. But
          // we can't set force to false since then information for the
          // sub sub menus is lost.
          if (recursive) {
            IContributionItem item = src;
            if (item instanceof SubContributionItem) {
              item = ((SubContributionItem) item).getInnerItem();
            }
            if (item instanceof IMenuManager) {
              ((IMenuManager) item).updateAll(force);
            }
          }
        }

        // remove any old menu items not accounted for
        for (; srcIx < mi.length; srcIx++) {
          mi[srcIx].dispose();
        }

        setDirty(false);
      }
    } else {
      // I am not dirty. Check if I must recursivly walk down the hierarchy.
      if (recursive) {
        IContributionItem[] items = getItems();
        for (int i = 0; i < items.length; ++i) {
          IContributionItem ci = items[i];
          if (ci instanceof IMenuManager) {
            IMenuManager mm = (IMenuManager) ci;
            if (isChildVisible(mm)) {
              mm.updateAll(force);
            }
          }
        }
      }
    }
    updateMenuItem();
  }
Ejemplo n.º 7
0
 /**
  * Call an <code>IContributionItem</code>'s fill method with the implementation's widget. The
  * default is to use the <code>Menu</code> widget.<br>
  * <code>fill(Menu menu, int index)</code>
  *
  * @param ci An <code>IContributionItem</code> whose <code>fill()</code> method should be called.
  * @param index The position the <code>fill()</code> method should start inserting at.
  * @since 3.4
  */
 protected void doItemFill(IContributionItem ci, int index) {
   ci.fill(menu, index);
 }