TrimAdditionCacheEntry.java :  » IDE-Eclipse » ui-workbench » org » eclipse » ui » internal » menus » Java Open Source

Java Open Source » IDE Eclipse » ui workbench 
ui workbench » org » eclipse » ui » internal » menus » TrimAdditionCacheEntry.java
/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.menus;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.expressions.Expression;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.menus.IWidget;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.internal.util.Util;
import org.eclipse.ui.menus.IMenuService;
import org.eclipse.ui.menus.IWorkbenchWidget;

/**
 * Handles the top level caching for 3.2 style trim
 * contributions.
 * 
 * @since 3.3
 * 
 */
public class TrimAdditionCacheEntry  {
  private IConfigurationElement additionElement;
  private MenuLocationURI uri = null;
  
  /**
   * The map contains {@link IWorkbenchWidget} entries
   * for widgets that have failed to load on a previous
   * attempt. Used to prevent multiple retries at
   * loading a widget (which spams the log).
   */
  private Map failedWidgets = new HashMap();
  /**
   * Maps the widget back to it's configurtation element
   */
  private Map widgetToConfigElementMap = new HashMap();
  

  // Caches

  /**
   * Maps an IContributionItem to its corresponding IConfigurationElement
   */
  Map iciToConfigElementMap = new HashMap();

  public TrimAdditionCacheEntry(IConfigurationElement element,
      MenuLocationURI uri, IMenuService service) {
    this.additionElement = element;
    this.uri = uri;
  }

  /**
   * Populate the list
   * 
   * @param additions
   */
  public void getContributionItems(List additions) {
    additions.clear();

  }

  /* (non-Javadoc)
   * @see org.eclipse.ui.internal.menus.MenuCacheEntry#generateSubCaches()
   */
  public void generateSubCaches() {
    // TODO Auto-generated method stub
    
  }

  /* (non-Javadoc)
   * @see org.eclipse.ui.internal.menus.MenuCacheEntry#getVisibleWhenForItem(org.eclipse.jface.action.IContributionItem)
   */
  public Expression getVisibleWhenForItem(IContributionItem item) {
    // TODO Auto-generated method stub
    return null;
  }

  /**
   * @return
   */
  public String getId() {
    return additionElement.getAttribute(IWorkbenchRegistryConstants.ATT_ID);
  }

  /**
   * @return <code>true</code> iff the group is positioned at the start
   * (or 'before') the entry that it is relative to. Default is true
   * 
   */
  public boolean isAtStart() {
    IConfigurationElement location = additionElement.getChildren(IWorkbenchRegistryConstants.TAG_LOCATION)[0];
    if (location.getChildren(IWorkbenchRegistryConstants.TAG_ORDER).length > 0) {
      IConfigurationElement order = location.getChildren(IWorkbenchRegistryConstants.TAG_ORDER)[0];
      
      String pos = order.getAttribute(IWorkbenchRegistryConstants.ATT_POSITION);
      if (pos != null)
        return (pos.equals("start") | pos.equals("before"));  //$NON-NLS-1$//$NON-NLS-2$
    }
    return true;
  }

  /**
   * Returns whether or not the defining {@link IConfigurationElement}
   * declares that the widget should use extra space in the 'major'
   * dimension (ie. use extra horizontal space in the status area).
   * The space is equally divided with other elementa in the same
   * trim area that also want to use the extra space.
   * 
   * @param widgetElement the {@link IConfigurationElement} declaring this
   * widget.
   * 
   * @return <code>true</code> iff the resulting widget should use
   * extra major space
   */
  public boolean fillMajor(IConfigurationElement widgetElement) {
    if (widgetElement.getChildren(IWorkbenchRegistryConstants.TAG_LAYOUT).length==0) {
      return false;
    }
    IConfigurationElement layout = widgetElement.getChildren(IWorkbenchRegistryConstants.TAG_LAYOUT)[0];
    String fillMajorVal = layout.getAttribute(IWorkbenchRegistryConstants.ATT_FILL_MAJOR);

    return (fillMajorVal != null && fillMajorVal.equals("true")); //$NON-NLS-1$
  }

  /**
   * Returns whether or not the defining {@link IConfigurationElement}
   * declares that the widget should use extra space in the 'minor'
   * dimension (ie. use extra vertical space in the status area)
   * 
   * @param widgetElement the {@link IConfigurationElement} declaring this
   * widget.
   * 
   * @return <code>true</code> iff the resulting widget should use
   * extra minor space
   */
  public boolean fillMinor(IConfigurationElement widgetElement) {
    if (widgetElement.getChildren(IWorkbenchRegistryConstants.TAG_LAYOUT).length==0) {
      return false;
    }
    IConfigurationElement layout = widgetElement.getChildren(IWorkbenchRegistryConstants.TAG_LAYOUT)[0];
    String fillMinorVal = layout.getAttribute(IWorkbenchRegistryConstants.ATT_FILL_MINOR);

    return (fillMinorVal != null && fillMinorVal.equals("true")); //$NON-NLS-1$
  }

  /**
   * @return The list of IConfigurationElements representing
   * widgets to be added into this 'group'
   */
  private List getWidgetConfigs() {
    List widgetConfigs = new ArrayList();
    
    // Return to the 'root' of the config tree and gather all elements
    // for this 'group'. Note that while this is sub-optimal
    // performace-wise that there are expected to be -very-
    // few contributions in total (i.e. 10's, not 100's)
    final IExtensionRegistry registry = Platform.getExtensionRegistry();
    final IConfigurationElement[] widgetElements = registry
        .getConfigurationElementsFor(IWorkbenchRegistryConstants.EXTENSION_MENUS);

    // Locate all 'widget' additions appropriate for -this- group
    for (int i = 0; i < widgetElements.length; i++) {
      // Only process 'widget' entries
      if (!IWorkbenchRegistryConstants.TAG_WIDGET.equals(widgetElements[i].getName()))
        continue;
      
      // Define the initial URI spec
      if (widgetElements[i].getChildren(IWorkbenchRegistryConstants.TAG_LOCATION).length > 0) {
        IConfigurationElement location = widgetElements[i].getChildren(IWorkbenchRegistryConstants.TAG_LOCATION)[0];
        if (location.getChildren(IWorkbenchRegistryConstants.TAG_BAR).length > 0) {
          IConfigurationElement bar = location.getChildren(IWorkbenchRegistryConstants.TAG_BAR)[0];

          // The bar's path represents the 'group' it should go into
          String path = bar.getAttribute(IWorkbenchRegistryConstants.ATT_PATH);
          if (path != null && path.equals(getId()))
              widgetConfigs.add(widgetElements[i]);
        }
      }
    }
    
    return widgetConfigs;
  }
  
  /**
   * Attempts to load -all- widgets for this entry and
   * keeps track of the successful loads only. Only elements
   * who can be successfully loaded will be seen by the
   * builder.
   * 
   * @return The list of <code>IWorkbenchWidget</code> entries
   * that have been successfully loaded 
   */
  public List getWidgets() {
    List loadedWidgets = new ArrayList();
    
    // Get the widget config elements for this 'group'
    List widgetConfigs = getWidgetConfigs();
    for (Iterator iterator = widgetConfigs.iterator(); iterator
        .hasNext();) {
      IConfigurationElement widgetCE = (IConfigurationElement) iterator.next();
      
      // skip elements that are known to fail
      if (failedWidgets.containsKey(widgetCE))
        continue;
      
      IWorkbenchWidget loadedWidget = loadWidget(widgetCE);

      // Either add it to the 'valid' list or mark it
      // as failed
      if (loadedWidget != null) {
        loadedWidgets.add(loadedWidget);
        widgetToConfigElementMap.put(loadedWidget, widgetCE);
      }
      else
        failedWidgets.put(widgetCE, widgetCE);
    }
    
    return loadedWidgets;
  }

  /**
   * Attempts to load the executable extension defined within the given
   * configuration element. An error is logged for any widget that fails
   * to load.
   * 
   * @param widgetCE The {@link IConfigurationElement} containing the
   * widget's 'class' specification.
   * 
   * @return The loaded {@link IWorkbenchWidget} or <code>null</code>
   * if the loading fails
   */
  private IWorkbenchWidget loadWidget(IConfigurationElement widgetCE) {
    return (IWorkbenchWidget) Util.safeLoadExecutableExtension(widgetCE,
          IWorkbenchRegistryConstants.ATT_CLASS,
          IWorkbenchWidget.class);
  }

  /**
   * @param widget The {@link IWorkbenchWidget} to get the defining configuration
   * element for.
   * 
   * @return The defining {@link IConfigurationElement}
   */
  public IConfigurationElement getElement(IWorkbenchWidget widget) {
    return (IConfigurationElement) widgetToConfigElementMap.get(widget);
  }

  /**
   * @param widget
   */
  public void removeWidget(IWidget widget) {
    widgetToConfigElementMap.remove(widget);
  }
  
  public MenuLocationURI getUri() {
    return uri;
  }
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.