Attachment #69495 for bug #131855




/*******************************************************************************
 * Copyright (c) 2001, 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.views.properties.tabbed.view;

import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;

/**
 * A property tab is composed by one or more property sections and is used to
 * categorize sections.
 * 
 * @author Anthony Hunter
 */
public class Tab {

    private ISection[] sections;

    private boolean controlsCreated;

    Tab() {
        controlsCreated = false;
    }

    /**
     * Retrieve a numbered index for the section.
     * @param section the section.
     * @return the section index.
     */
    public int getSectionIndex(ISection section) {
        for (int i = 0; i < sections.length; i++) {
			if (section == sections[i]) {
				return i;
			}
		}
        return -1;
    }

    /**
     * Retrieve the section at a numbered index.
     * @param i a numbered index.
     * @return the section.
     */
    public ISection getSectionAtIndex(int i) {
        if (i >= 0 && i < sections.length) {
			return sections[i];
		}
        return null;
    }

    /**
     * Retrieve the sections on the tab.
     * 
     * @return the sections on the tab.
     */
    public ISection[] getSections() {
        return sections;
    }

    /**
     * Creates page's sections controls.
     * 
     * @param parent
     * @param page
     */
    public void createControls(Composite parent,
            final TabbedPropertySheetPage page) {
        Composite pageComposite = page.getWidgetFactory().createComposite(
            parent, SWT.NO_FOCUS);
        GridLayout layout = new GridLayout();
        layout.marginWidth = 0;
        layout.marginHeight = 0;
        layout.verticalSpacing = 0;
        pageComposite.setLayout(layout);

        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            final Composite sectionComposite = page.getWidgetFactory()
                .createComposite(pageComposite, SWT.NO_FOCUS);
            sectionComposite.setLayout(new FillLayout());
            int style = (section.shouldUseExtraSpace()) ? GridData.FILL_BOTH
                : GridData.FILL_HORIZONTAL;
            GridData data = new GridData(style);
            data.heightHint = section.getMinimumHeight();
            sectionComposite.setLayoutData(data);

            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.createControls(sectionComposite, page);
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
        controlsCreated = true;
    }

    /**
     * Dispose of page's sections controls.
     */
    public void dispose() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.dispose();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sends the lifecycle event to the page's sections.
     */
    public void aboutToBeShown() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.aboutToBeShown();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sends the lifecycle event to the page's sections.
     */
    public void aboutToBeHidden() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.aboutToBeHidden();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sets page's sections input objects.
     * 
     * @param part
     * @param selection
     */
    public void setInput(final IWorkbenchPart part, final ISelection selection) {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.setInput(part, selection);
                }

                public void handleException(Throwable throwable) {
                    throwable.printStackTrace();
                }
            };
            Platform.run(runnable);
        }
    }

    void setSections(ISection[] sections) {
        this.sections = sections;
    }

    /**
     * 
     * @return <code>true</code> if controls have been created.
     */
    public boolean controlsHaveBeenCreated() {
        return controlsCreated;
    }

    /**
     * If controls have been created, refresh all sections on the page.
     */
    public void refresh() {
        if (controlsCreated) {
            for (int i = 0; i < sections.length; i++) {
                final ISection section = sections[i];
                ISafeRunnable runnable = new ISafeRunnable() {

                    public void run()
                        throws Exception {
                        section.refresh();
                    }

                    public void handleException(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                };
                Platform.run(runnable);
            }
        }
    }
}




import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;


/**

 * tabbed property sheet page's list of tabs.
 * 
 * @author Anthony Hunter
 * @version 30 May 2007
 */
public class TabListContentProvider
	implements IStructuredContentProvider {
	
	private TabbedPropertySheetPage tabbedPropertyPage;

	private IWorkbenchPart currentPart;
	
	/**
	 * Constructor for TabListContentProvider.
	 * This content provider always returns the "current tabs" of the given
	 * property page
	 * #see {@link TabbedPropertySheetPage.#getCurrentTabs()} 
	 */
	public TabListContentProvider(TabbedPropertySheetPage tabbedPropertyPage) {
		this.tabbedPropertyPage = tabbedPropertyPage;
	}
	
	/**

	 */
	public Object[] getElements(Object inputElement) {
		Assert.isTrue(inputElement instanceof ISelection);
			return tabbedPropertyPage.getCurrentTabs();
			.getTabDescriptors(currentPart, (ISelection) inputElement);
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
	 */
	public void dispose() {
		tabbedPropertyPage = null;
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		this.currentPart = ((TabbedPropertyViewer)viewer).getWorkbenchPart();
	}
}




 *******************************************************************************/
package org.eclipse.ui.internal.views.properties.tabbed.view;

import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.views.properties.tabbed.AbstractTabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITabItem;

/**

 * property tabs extensions.
 * 
 * @author Anthony Hunter
 * @version 22 May 2007
 */
public class TabDescriptor extends AbstractTabDescriptor
	implements Cloneable, ITabItem, ITabDescriptor {

	private static final String ATT_ID = "id"; //$NON-NLS-1$



	private static final String ATT_AFTER_TAB = "afterTab"; //$NON-NLS-1$

	private static final String TOP = "top"; //$NON-NLS-1$

	private final static String TAB_ERROR = TabbedPropertyMessages.TabDescriptor_Tab_error;

	private String id;

	private String label;

	private Image image;

	private boolean selected;

	private boolean indented;

	private String category;

	private String afterTab;

	private List sectionDescriptors;

	/**
	 * Constructor for TabDescriptor.
	 * 

	 *            the configuration element for the tab descriptor.
	 */
	public TabDescriptor(IConfigurationElement configurationElement) {
		super();
		
		if (configurationElement != null) {
			String id = configurationElement.getAttribute(ATT_ID);
			String label = configurationElement.getAttribute(ATT_LABEL);
			String imageString = configurationElement.getAttribute(ATT_IMAGE);
			if (imageString != null) {
				Image image = AbstractUIPlugin
					.imageDescriptorFromPlugin(
						configurationElement.getDeclaringExtension()
							.getNamespace(), imageString).createImage();
				if (image != null) {
					setImage(image);
				}
			}
			String indentedString = configurationElement
				.getAttribute(ATT_INDENTED);
			boolean indented = indentedString != null && indentedString.equals("true"); //$NON-NLS-1$
			setIndented(indented);
			String category = configurationElement.getAttribute(ATT_CATEGORY);
			String afterTab = configurationElement.getAttribute(ATT_AFTER_TAB);
			setAfterTab(afterTab);
			if (id == null || label == null || category == null) {
				// the tab id, label and category are mandatory - log error
				handleTabError(configurationElement.getContributor().getName(), null);
			}
		}
		if (getAfterTab() == null) {
			afterTab = TOP;
		}
		sectionDescriptors = new ArrayList(5);
		selected = false;
	}

	/**
	 * Get the unique identifier for the tab.
	 * 
	 * @return the unique identifier for the tab.
	 */
	public String getId() {
		return id;
	}

	/**
	 * Get the text label for the tab.
	 * 
	 * @return the text label for the tab.
	 */
	public String getLabel() {
		return label;
	}

	/**
	 * Get the identifier of the tab after which this tab should be displayed.
	 * When two or more tabs belong to the same category, they are sorted by the
	 * after tab values.
	 * 
	 * @return the identifier of the tab.
	 */
	protected String getAfterTab() {
		return afterTab;
	}

	/**
	 * Get the category this tab belongs to.
	 * 
	 * @return Get the category this tab belongs to.
	 */
	protected String getCategory() {
		return category;
	}

	/**
	 * Returns whether the given section was added to this tab. The section can
	 * be appended if its tab attribute matches the tab id. The afterSection
	 * attribute indicates the order in which the section should be appended.
	 * 
	 * @param target
	 *            the section descriptor to append.
	 */
	protected boolean append(ISectionDescriptor target) {
		if (!target.getTargetTab().equals(id)) {
			return false;
		}

		if (insertSectionDescriptor(target)) {
			return true;
		}

		sectionDescriptors.add(target);
		return true;
	}

	/**
	 * Insert the section descriptor into the section descriptor list.
	 * 
	 * @param target
	 *            the section descriptor to insert.
	 * @return <code>true</code> if the target descriptor was added to the
	 *         descriptors list.
	 */
	private boolean insertSectionDescriptor(ISectionDescriptor target) {
		if (target.getAfterSection().equals(TOP)) {
			sectionDescriptors.add(0, target);
			return true;
		}
		for (int i = 0; i < sectionDescriptors.size(); i++) {
			ISectionDescriptor descriptor = (ISectionDescriptor) sectionDescriptors
				.get(i);
			if (target.getAfterSection().equals(descriptor.getId())) {
				sectionDescriptors.add(i + 1, target);
				return true;
			} else {
				if (descriptor.getAfterSection().equals(target.getId())) {
					sectionDescriptors.add(i, target);
					return true;
				}
			}
			
			setId(id);
			setLabel(label);
			setCategory(category);
		}
		
	}

	/**
	 * Instantiate this tab's sections.
	 */
	public Tab createTab() {
		List sections = new ArrayList(sectionDescriptors.size());
		for (Iterator iter = sectionDescriptors.iterator(); iter.hasNext();) {
			ISectionDescriptor descriptor = (ISectionDescriptor) iter.next();
			ISection section = descriptor.getSectionClass();
			sections.add(section);
		}
		Tab tab = new Tab();
		tab.setSections((ISection[]) sections.toArray(new ISection[sections
			.size()]));
		return tab;
	}

	/**
	 * Get the list of section descriptors for the tab.
	 * 
	 * @return the list of section descriptors for the tab.
	 */
	protected List getSectionDescriptors() {
		return sectionDescriptors;
	}

	/**

	 * 
	 * @param sectionDescriptors
	 *            the list of section descriptors for the tab.
	 */
	protected void setSectionDescriptors(List sectionDescriptors) {
		this.sectionDescriptors = sectionDescriptors;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return getId();
	}

	 * Made this publicly accessible to {@link TabbedPropertyRegistry}  
	 * Handle the tab error when an issue is found loading from the
	 * configuration element.
	 * 
	 * @param configurationElement
	 *            the configuration element
	 * @param exception
	 *            an optional CoreException
	 */
	private void handleTabError(IConfigurationElement configurationElement,
			CoreException exception) {
		String pluginId = configurationElement.getDeclaringExtension()
			.getNamespace();
		String message = MessageFormat.format(TAB_ERROR,
			new Object[] {pluginId});
		IStatus status = new Status(IStatus.ERROR, pluginId,
			TabbedPropertyViewStatusCodes.TAB_ERROR, message, exception);
		TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
	}

	/**
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object object) {
		if (this == object) {
			return true;
		}

		if (this.getClass() == object.getClass()) {
			TabDescriptor descriptor = (TabDescriptor) object;
			if (this.getCategory().equals(descriptor.getCategory())
				&& this.getId().equals(descriptor.getId())
				&& this.getSectionDescriptors().size() == descriptor
					.getSectionDescriptors().size()) {

				Iterator i = this.getSectionDescriptors().iterator();
				Iterator j = descriptor.getSectionDescriptors().iterator();

				// the order is importent here - so as long as the sizes of the
				// lists are the same and id of the section at the same
				// positions are the same - the lists are the same
				while (i.hasNext()) {
					ISectionDescriptor source = (ISectionDescriptor) i.next();
					ISectionDescriptor target = (ISectionDescriptor) j.next();
					if (!source.getId().equals(target.getId())) {
						return false;
					}
				}

				return true;
			}

		}

		return false;
	}

	/**
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {

		int hashCode = getCategory().hashCode();
		hashCode ^= getId().hashCode();
		Iterator i = this.getSectionDescriptors().iterator();
		while (i.hasNext()) {
			ISectionDescriptor section = (ISectionDescriptor) i.next();
			hashCode ^= section.getId().hashCode();
		}
		return hashCode;
	}

	/**
	 * @see java.lang.Object#clone()
	 */
	public Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException exception) {
			IStatus status = new Status(IStatus.ERROR, TabbedPropertyViewPlugin
				.getPlugin().getBundle().getSymbolicName(), 666, exception
				.getMessage(), exception);
			TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
		}
		return null;
	}

	/**
	 * Set the image for the tab.
	 * 
	 * @param image
	 *            the image for the tab.
	 */
	protected void setImage(Image image) {
		this.image = image;
	}

	/**
	 * Set the indicator to determine if the tab should be displayed as
	 * indented.
	 * 
	 * @param indented
	 *            <code>true</code> if the tab should be displayed as
	 *            indented.
	 */
	protected void setIndented(boolean indented) {
		this.indented = indented;
	}

	/**
	 * Set the indicator to determine if the tab should be the selected tab in
	 * the list.
	 * 
	 * @param selected
	 *            <code>true</code> if the tab should be the selected tab in
	 *            the list.
	 */
	protected void setSelected(boolean selected) {
		this.selected = selected;
	}

	/**
	 * Set the text label for the tab.
	 * 
	 * @param label
	 *            the text label for the tab.
	 */
	protected void setLabel(String label) {
		this.label = label;
	}

	/**
	 * Get the image for the tab.
	 * 
	 * @return the image for the tab.
	 */
	public Image getImage() {
		return image;
	}

	/**
	 * Determine if the tab is selected.
	 * 
	 * @return <code>true</code> if the tab is selected.
	 */
	public boolean isSelected() {
		return selected;
	}

	/**
	 * Determine if the tab should be displayed as indented.
	 * 
	 * @return <code>true</code> if the tab should be displayed as indented.
	 */
	public boolean isIndented() {
		return indented;
	}

	/**
	 * Get the text label for the tab.
	 * 
	 * @return the text label for the tab.
	 */
	public void setSectionDescriptors(List aSectionDescriptors) {
		super.setSectionDescriptors(aSectionDescriptors);
	}
}




 *******************************************************************************/
package org.eclipse.ui.internal.views.properties.tabbed.view;

import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;


import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.viewers.IFilter;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.views.properties.tabbed.AbstractSectionDescriptor;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.ISectionDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITypeMapper;

import com.ibm.icu.text.MessageFormat;

/**
 * Represents the default implementation of a section descriptor on the tabbed
 * property sections extensions. This implementation assumes that we are
 * interested in selected objects in an IStructuredSelection.
 * 
 * @author Anthony Hunter
 * @version 21 May 2007
 */
public class SectionDescriptor
	extends AbstractSectionDescriptor {

	private final static String SECTION_ERROR = TabbedPropertyMessages.SectionDescriptor_Section_error;



	private static final String ELEMENT_INPUT = "input"; //$NON-NLS-1$

	private static final String TOP = "top"; //$NON-NLS-1$

	private String id;

	private String targetTab;

	private String afterSection;

	private ArrayList inputTypes;

	private TabbedPropertyRegistryClassSectionFilter classFilter;

	private IFilter filter;

	private int enablesFor = ENABLES_FOR_ANY;

	private IConfigurationElement configurationElement;

	/**

	 */
	protected SectionDescriptor(IConfigurationElement configurationElement,
			ITypeMapper typeMapper) {
		super();
		
		this.configurationElement = configurationElement;

		setTypeMapper(typeMapper);
		String id = getConfigurationElement().getAttribute(ATT_ID);
		String targetTab = getConfigurationElement().getAttribute(ATT_TARGET_TAB);
		String afterSection = getConfigurationElement()
			.getAttribute(ATT_AFTER_SECTION);
		if (getConfigurationElement().getAttribute(ATT_SECTION_ENABLES_FOR) != null) {
			String enablesForStr = getConfigurationElement().getAttribute(
				ATT_SECTION_ENABLES_FOR);
			int enablesForTest = Integer.parseInt(enablesForStr);
			if (enablesForTest > 0) {
				setEnablesFor(enablesForTest);
			}
		}


			// the section id and tab are mandatory - log error
			handleSectionError(null);
		}
		
		if (afterSection != null) {
			setAfterSection(afterSection);
		}
		if (id != null) {
			setId(id);
		}
		if (targetTab != null) {
			setTargetTab(targetTab);
		}
	}


	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getId()
	 */
	public String getId() {
		return id;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getFilter()
	 */
	public IFilter getFilter() {

	}

	/**
	 * Retrieves the value for section enablement which is a precise number of
	 * items selected. For example: enablesFor=" 4" enables the action only when
	 * 4 items are selected. If not specified, enable for all selections.
	 * 
	 * @return the value for section enablement.
	 */
	public int getEnablesFor() {
		return enablesFor;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getTargetTab()
	 */
	public String getTargetTab() {
		return targetTab;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#appliesTo(org.eclipse.ui.IWorkbenchPart,
	 *      org.eclipse.jface.viewers.ISelection)
	 */
	public boolean appliesTo(IWorkbenchPart part, ISelection selection) {
		return classFilter.appliesToSelection(this, selection);
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getAfterSection()
	 */
	public String getAfterSection() {
		return afterSection;
	}

	/**
	 * Creates an instance of a section described by this descriptor
	 * 
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getSectionClass()

	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return getId();
	}

	/**
	 * @return Returns the configurationElement.
	 */
	private IConfigurationElement getConfigurationElement() {




 *******************************************************************************/
package org.eclipse.ui.internal.views.properties.tabbed.view;

import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.views.properties.tabbed.*;

import com.ibm.icu.text.MessageFormat;
import org.eclipse.ui.views.properties.tabbed.ITypeMapper;

/**
 * Provides information about the tabbed property extension points. Each tabbed
 * property registry is associated with a unique contributor ID.
 * 
 * @author Anthony Hunter
 * @version 22 May 2007
 */
public class TabbedPropertyRegistry implements ITabDescriptorProvider {

	private final static String NO_TAB_ERROR = TabbedPropertyMessages.TabbedPropertyRegistry_Non_existing_tab;



    private static final String ATT_ACTION_PROVIDER = "actionProvider"; //$NON-NLS-1$

	private static final String TOP = "top"; //$NON-NLS-1$

	protected String contributorId;

	protected IConfigurationElement contributorConfigurationElement;

	}

	/**
	 * Returns the index of the given element in the array.
	 */
	private int getIndex(Object[] array, Object target) {
		for (int i = 0; i < array.length; i++) {
			if (array[i].equals(target)) {
				return i;
			}
		}
		return -1; // should never happen
	}

	/**
	 * Returns property tab descriptors for the given contributor id and object
	 * input. The descriptors are sorted using the afterPage attribute.
	 */
	public ITabDescriptor[] getTabDescriptors(IWorkbenchPart part,
			ISelection selection) {
		if (selection == null || selection.isEmpty()) {
			return EMPTY_DESCRIPTOR_ARRAY;
		}

		TabDescriptor[] allDescriptors = getAllTabDescriptors();
		ITabDescriptor[] result = filterTabDescriptors(allDescriptors, part,
			selection);
		return result;
	}

		if (tabDescriptors == null) {
			List temp = readTabDescriptors();
			populateWithSectionDescriptors(temp);
			tabDescriptors = (TabDescriptor[]) temp.toArray(new TabDescriptor[temp.size()]);
			temp = sortTabDescriptorsByAfterTab(temp);
			tabDescriptors = (TabDescriptor[]) temp
				.toArray(new TabDescriptor[temp.size()]);
		}
		return tabDescriptors;
	}

			IConfigurationElement[] tabs = extension.getChildren(ELEMENT_TAB);
			for (int j = 0; j < tabs.length; j++) {
				IConfigurationElement tab = tabs[j];
				ITabDescriptor descriptor = new TabDescriptor(tab);
				result.add(descriptor);
			}
		}

	protected void appendToTabDescriptor(ISectionDescriptor section,
			List aTabDescriptors) {
		for (Iterator i = aTabDescriptors.iterator(); i.hasNext();) {
			AbstractTabDescriptor tab = (AbstractTabDescriptor) i.next();
			if (tab.append(section)) {
				return;
			}

	}

	/**
	 * Sorts the tab descriptors in the given list according to category.
	 */
	protected List sortTabDescriptorsByCategory(List descriptors) {
		Collections.sort(descriptors, new Comparator() {

			public int compare(Object arg0, Object arg1) {
				TabDescriptor one = (TabDescriptor) arg0;
				TabDescriptor two = (TabDescriptor) arg1;
				String categoryOne = one.getCategory();
				String categoryTwo = two.getCategory();
				int categoryOnePosition = getIndex(propertyCategories.toArray(),
					categoryOne);
				int categoryTwoPosition = getIndex(propertyCategories.toArray(),
					categoryTwo);
				return categoryOnePosition - categoryTwoPosition;
			}
		});
		return descriptors;
	}

	/**
	 * Sorts the tab descriptors in the given list according to afterTab.
	 */
	protected List sortTabDescriptorsByAfterTab(List tabs) {
		if (tabs.size() == 0 || propertyCategories == null) {
			return tabs;
		}
		List sorted = new ArrayList();
		int categoryIndex = 0;
		for (int i = 0; i < propertyCategories.size(); i++) {
			List categoryList = new ArrayList();
			String category = (String)propertyCategories.get(i);
			int topOfCategory = categoryIndex;
			int endOfCategory = categoryIndex;
			while (endOfCategory < tabs.size()
				&& ((TabDescriptor) tabs.get(endOfCategory)).getCategory()
					.equals(category)) {
				endOfCategory++;
			}
			for (int j = topOfCategory; j < endOfCategory; j++) {
				TabDescriptor tab = (TabDescriptor) tabs.get(j);
				if (tab.getAfterTab().equals(TOP)) {
					categoryList.add(0, tabs.get(j));
				} else {
					categoryList.add(tabs.get(j));
				}
			}
			Collections.sort(categoryList, new Comparator() {

				public int compare(Object arg0, Object arg1) {
					TabDescriptor one = (TabDescriptor) arg0;
					TabDescriptor two = (TabDescriptor) arg1;
					if (two.getAfterTab().equals(one.getId())) {
						return -1;
					} else if (one.getAfterTab().equals(two.getId())) {
						return 1;
					} else {
						return 0;
					}
				}
			});
			for (int j = 0; j < categoryList.size(); j++) {
				sorted.add(categoryList.get(j));
			}
			categoryIndex = endOfCategory;
		}
		return sorted;
	}

	/**
	 * Gets the type mapper for the contributor.
	 * 
	 * @return the type mapper for the contributor.

    public IActionProvider getActionProvider() {
        return actionProvider;
    }

	/**

	 * Sets the section descriptor provider for the contributor.
	 * 
	 * @param sectionDescriptorProvider




 * IStructuredSelection and filtering is based on class.
 * 
 * @author Anthony Hunter
 * @version 15 May 2007
 */
public class TabbedPropertyRegistryClassSectionFilter {


	/**
	 * constructor.
	 */
	public TabbedPropertyRegistryClassSectionFilter(ITypeMapper typeMapper) {
		super();
		this.typeMapper = typeMapper;
	}

	 * Verifies if the property section extension represented by sectionElement
	 * applies to the given input.
	 */
	public boolean appliesToSelection(ISectionDescriptor descriptor,
			ISelection selection) {

		if (selection instanceof IStructuredSelection

Lines 12-22 Link Here

(-)src/org/eclipse/ui/views/properties/tabbed/ITabSelectionListener.java (+3 lines)
12		12
13	import org.eclipse.ui.internal.views.properties.tabbed.view.TabDescriptor;	13	import org.eclipse.ui.internal.views.properties.tabbed.view.TabDescriptor;
14		14
		15
15	/**	16	/**
16	* A listener interested in tab selection events that occur for the tabbed	17	* A listener interested in tab selection events that occur for the tabbed
17	* property sheet page.	18	* property sheet page.
18	*	19	*
19	* @author Anthony Hunter	20	* @author Anthony Hunter
		21	* @version 21 May 2007
		22	* @deprecated use {@link ITabSelectionListener2} instead
20	*/	23	*/
21	public interface ITabSelectionListener {	24	public interface ITabSelectionListener {
22		25




 *******************************************************************************/
package org.eclipse.ui.views.properties.tabbed;

import java.util.*;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.*;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.internal.views.properties.tabbed.view.*;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabDescriptor;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabListContentProvider;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyRegistry;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyRegistryFactory;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyTitle;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyViewer;
import org.eclipse.ui.part.IContributedContentsView;
import org.eclipse.ui.part.Page;
import org.eclipse.ui.views.properties.IPropertySheetPage;

 * A property sheet page that provides a tabbed UI.
 * 
 * @author Anthony Hunter
 * @version 31 May 2007
 */
public class TabbedPropertySheetPage
	extends Page


	private TabbedPropertyViewer tabbedPropertyViewer;

	private TabContents currentTab;
	
	private ITabDescriptor[] currentTabs;

	private Map descriptorToTab;


	private boolean selectionQueueLocked;

	private List tabSelectionListeners;
	private List tabSelectionListeners2;

	private IWorkbenchWindow cachedWorkbenchWindow;

	private boolean hasTitleBar;

	private TabDescriptorProviderManager tabDescriptorManager;

	/**
	 * a listener that is interested in part activation events.
	 */

		}
	};



	private class TabbedPropertySheetPageContributorFromSelection
		implements ITabbedPropertySheetPageContributor {


		extends LabelProvider {

		public String getText(Object element) {
			if (element instanceof AbstractTabDescriptor) {
				return ((ITabDescriptor) element).getLabel();
			}
			return null;
		}

		public void selectionChanged(SelectionChangedEvent event) {
			IStructuredSelection selection = (IStructuredSelection) event
				.getSelection();
			TabContents tab = null;
			ITabDescriptor descriptor = (ITabDescriptor) selection
				.getFirstElement();

			if (descriptor == null) {

				// create tab if necessary
				// can not cache based on the id - tabs may have the same id,
				// but different section depending on the selection
				tab = (TabContents) descriptorToTab.get(descriptor);

				if (tab != currentTab) {
					hideTab(currentTab);

		/**
		 * Shows the given tab.
		 */
		private void showTab(TabContents target) {
			if (target != null) {
				Composite tabComposite = (Composite) tabToComposite.get(target);
				if (tabComposite != null) {

		/**
		 * Hides the given tab.
		 */
		private void hideTab(TabContents target) {
			if (target != null) {
				Composite tabComposite = (Composite) tabToComposite.get(target);
				if (tabComposite != null) {

		contributor = tabbedPropertySheetPageContributor;
		tabToComposite = new HashMap();
		selectionQueue = new ArrayList(10);
		tabSelectionListeners2 = new ArrayList();
		tabDescriptorManager = new TabDescriptorProviderManager();
		initContributor(contributor.getContributorId());
	}


	 */
	private void initContributor(String contributorId) {
		descriptorToTab = new HashMap();
		TabbedPropertyRegistry oldRegistry = registry;
		
		if (contributor.getContributorId().equals(contributorId)) {
			/**
			 * default contributor from the workbench part.

			registry = TabbedPropertyRegistryFactory.getInstance()
				.createRegistry(selectionContributor);
		}
		if (oldRegistry != null && !oldRegistry.equals(registry)) {
			tabDescriptorManager.removeTabDescriptorProvider(oldRegistry);
		}
		tabDescriptorManager.insertTabDescriptorProvider(0, registry);
		
		currentContributorId = contributorId;
		tabListContentProvider = getTabListContentProvider();
		hasTitleBar = registry.getLabelProvider() != null;

	 * @return the tab list content provider for the contributor.
	 */
	protected IStructuredContentProvider getTabListContentProvider() {
		return new TabListContentProvider(this);
	}

	/**

	}

	/**
	 * Stores the current tab label in the selection queue. TabContents labels are used
	 * to carry the tab context from one input object to another. The queue
	 * specifies the selection priority. So if the first tab in the queue is not
	 * available for the input we try the second tab and so on. If none of the


	private void disposeTabs(Collection tabs) {
		for (Iterator iter = tabs.iterator(); iter.hasNext();) {
			TabContents tab = (TabContents) iter.next();
			Composite composite = (Composite) tabToComposite.remove(tab);
			tab.dispose();
			if (composite != null) {

	}

	/**
	 * Returns the last known selected tab for the current input
	 */
	private int getLastTabSelection() {
		ITabDescriptor[] descriptors = currentTabs;
		if (descriptors.length != 0) {
			for (Iterator iter = selectionQueue.iterator(); iter.hasNext();) {
				String text = (String) iter.next();

	 * disposed. If the current visible tab will not be reused (i.e. will be
	 * disposed) we have to send it an aboutToBeHidden() message.
	 */
	protected void updateTabs(ITabDescriptor[] descriptors) {
		Map newTabs = new HashMap(descriptors.length * 2);
		boolean disposingCurrentTab = (currentTab != null);
		for (int i = 0; i < descriptors.length; i++) {
			TabContents tab = (TabContents) descriptorToTab.remove(descriptors[i]);

			if (tab != null && tab.controlsHaveBeenCreated()) {
				if (tab == currentTab) {
					disposingCurrentTab = false;
				}
			} else {
				tab = createTab(descriptors[i]);
			}

			newTabs.put(descriptors[i], tab);

	}

	/**
	 * Creates a new {@link TabContents} for the given tabDescriptor
	 * @param aDescriptor the descriptor to create the new TabContents for
	 * @return the new TabContents
	 */
	protected TabContents createTab(ITabDescriptor tabDescriptor) {
		return tabDescriptor.createTab();
	}

	/**
	 * Helper method for creating property tab composites.
	 */
	private Composite createTabComposite() {


		// see if the selection provides a new contributor
		validateRegistry(selection);
		ITabDescriptor[] descriptors = getTabDescriptorsForSelection(part, currentSelection);
			currentSelection);
		// If there are no descriptors for the given input we do not need to
		// touch the tab objects. We might reuse them for the next valid
		// input.
		if (descriptors.length > 0) {
			updateTabs(descriptors);
		}
		// update the content provider, which must return exactly the above descriptors
		currentTabs = descriptors;
		
		// update tabs list
		tabbedPropertyViewer.setInput(part, currentSelection);
		int lastTabSelectionIndex = getLastTabSelection();
		Object selectedTab = tabbedPropertyViewer
			.getElementAt(lastTabSelectionIndex);
		selectionQueueLocked = true;

	}

	/**
	 * Returns the {@link ITabDescriptor} applicable to the given part and selection.
	 * These descriptors will be used and shown in the property sheet.
	 * @param part
	 * @param currentSelection
	 * @return The tab descriptors for the given selection 
	 */
	protected ITabDescriptor[] getTabDescriptorsForSelection(IWorkbenchPart part, ISelection currentSelection) {
		ITabDescriptor[] descriptors = tabDescriptorManager.getTabDescriptors(part,
				currentSelection);
		return descriptors;
	}

	/**
	 * Refresh the currently active tab.
	 */
	public void refresh() {

	 * 
	 * @return the currently active tab.
	 */
	public TabContents getCurrentTab() {
		return currentTab;
	}

	/**
	 * @return Returns the descriptors for the currently used tabs
	 */
	public ITabDescriptor[] getCurrentTabs() {
		return currentTabs;
	}
	
	/**
	 * Handle the tab selected change event.
	 * 
	 * @param tabDescriptor
	 *            the new selected tab.
	 */
	private void handleTabSelection(ITabDescriptor tabDescriptor) {
		if (selectionQueueLocked) {
			/*
			 * don't send tab selection events for non user changes.
			 */
			return;
		}
		if (tabSelectionListeners != null && tabDescriptor instanceof TabDescriptor) {
			for (Iterator i = tabSelectionListeners.iterator(); i.hasNext();) {
				ITabSelectionListener listener = (ITabSelectionListener) i.next();
				listener.tabSelected((TabDescriptor) tabDescriptor);
			}
		}
		
		for (Iterator i = tabSelectionListeners2.iterator(); i.hasNext();) {
			ITabSelectionListener2 listener = (ITabSelectionListener2) i.next();
			listener.tabSelected(tabDescriptor);
		}
	}

	 * 
	 * @param listener
	 *            a tab selection listener.
	 * @deprecated use {@link #addTabSelectionListener(ITabSelectionListener2)} instead
	 */
	public void addTabSelectionListener(ITabSelectionListener listener) {
		if (tabSelectionListeners == null) {
			tabSelectionListeners = new ArrayList();
		}
		tabSelectionListeners.add(listener);
	}


	 * 
	 * @param listener
	 *            a tab selection listener.
	 * @deprecated use {@link #removeTabSelectionListener(ITabSelectionListener2)}
	 */
	public void removeTabSelectionListener(ITabSelectionListener listener) {
		tabSelectionListeners.remove(listener);
		if (tabSelectionListeners.isEmpty()) {
			tabSelectionListeners = null;
		}
	}
	
	/**
	 * Add a tab selection listener.
	 * 
	 * @param listener
	 *            a tab selection listener.
	 */
	public void addTabSelectionListener(ITabSelectionListener2 listener) {
		tabSelectionListeners2.add(listener);
	}

	/**
	 * Remove a tab selection listener.
	 * 
	 * @param listener
	 *            a tab selection listener.
	 */
	public void removeTabSelectionListener(ITabSelectionListener2 listener) {
		tabSelectionListeners2.remove(listener);
	}

	/**




/*******************************************************************************
 * Copyright (c) 2001, 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.views.properties.tabbed;

import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IWorkbenchPart;

/**
 * A property tab is composed by one or more property sections and is used to
 * categorize sections.
 * 
 * @author Anthony Hunter
 * @version 14 May 2007
 */
public class TabContents {

    private ISection[] sections;

    private boolean controlsCreated;

    public TabContents() {
        controlsCreated = false;
    }

    /**
     * Retrieve a numbered index for the section.
     * @param section the section.
     * @return the section index.
     */
    public int getSectionIndex(ISection section) {
        for (int i = 0; i < sections.length; i++) {
			if (section == sections[i]) {
				return i;
			}
		}
        return -1;
    }

    /**
     * Retrieve the section at a numbered index.
     * @param i a numbered index.
     * @return the section.
     */
    public ISection getSectionAtIndex(int i) {
        if (i >= 0 && i < sections.length) {
			return sections[i];
		}
        return null;
    }

    /**
     * Retrieve the sections on the tab.
     * 
     * @return the sections on the tab.
     */
    public ISection[] getSections() {
        return sections;
    }

    /**
     * Creates page's sections controls.
     * 
     * @param parent
     * @param page
     */
    public void createControls(Composite parent,
            final TabbedPropertySheetPage page) {
        Composite pageComposite = page.getWidgetFactory().createComposite(
            parent, SWT.NO_FOCUS);
        GridLayout layout = new GridLayout();
        layout.marginWidth = 0;
        layout.marginHeight = 0;
        layout.verticalSpacing = 0;
        pageComposite.setLayout(layout);

        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            final Composite sectionComposite = page.getWidgetFactory()
                .createComposite(pageComposite, SWT.NO_FOCUS);
            sectionComposite.setLayout(new FillLayout());
            int style = (section.shouldUseExtraSpace()) ? GridData.FILL_BOTH
                : GridData.FILL_HORIZONTAL;
            GridData data = new GridData(style);
            data.heightHint = section.getMinimumHeight();
            sectionComposite.setLayoutData(data);

            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.createControls(sectionComposite, page);
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
        controlsCreated = true;
    }

    /**
     * Dispose of page's sections controls.
     */
    public void dispose() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.dispose();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sends the lifecycle event to the page's sections.
     */
    public void aboutToBeShown() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.aboutToBeShown();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sends the lifecycle event to the page's sections.
     */
    public void aboutToBeHidden() {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.aboutToBeHidden();
                }

                public void handleException(Throwable exception) {
                    /* not used */
                }
            };
            Platform.run(runnable);
        }
    }

    /**
     * Sets page's sections input objects.
     * 
     * @param part
     * @param selection
     */
    public void setInput(final IWorkbenchPart part, final ISelection selection) {
        for (int i = 0; i < sections.length; i++) {
            final ISection section = sections[i];
            ISafeRunnable runnable = new ISafeRunnable() {

                public void run()
                    throws Exception {
                    section.setInput(part, selection);
                }

                public void handleException(Throwable throwable) {
                    throwable.printStackTrace();
                }
            };
            Platform.run(runnable);
        }
    }

    public void setSections(ISection[] sections) {
        this.sections = sections;
    }

    /**
     * 
     * @return <code>true</code> if controls have been created.
     */
    public boolean controlsHaveBeenCreated() {
        return controlsCreated;
    }

    /**
     * If controls have been created, refresh all sections on the page.
     */
    public void refresh() {
        if (controlsCreated) {
            for (int i = 0; i < sections.length; i++) {
                final ISection section = sections[i];
                ISafeRunnable runnable = new ISafeRunnable() {

                    public void run()
                        throws Exception {
                        section.refresh();
                    }

                    public void handleException(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                };
                Platform.run(runnable);
            }
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2001, 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.views.properties.tabbed;

import java.util.Collections;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.viewers.IFilter;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyRegistryClassSectionFilter;

import com.ibm.icu.text.MessageFormat;

/**
 * Represents the default implementation of a section descriptor on the tabbed
 * property sections extensions. This implementation assumes that we are
 * interested in selected objects in an IStructuredSelection.
 * 
 * The id and targetTab properties are mandatory and must not be null. 
 * 
 * @author Anthony Hunter
 * @version 31 May 2007
 */
public abstract class AbstractSectionDescriptor
	implements ISectionDescriptor {

	private final static String SECTION_ERROR = TabbedPropertyMessages.SectionDescriptor_Section_error;

	private static final String TOP = "top"; //$NON-NLS-1$

	private String id;

	private String targetTab;

	private String afterSection;

	private TabbedPropertyRegistryClassSectionFilter classFilter;

	private IFilter filter;

	private int enablesFor = ENABLES_FOR_ANY;

	/**
	 * Constructor for the section descriptor.
	 * 
	 * @param id 
	 * 			The id of this section descriptor (must not be null).
	 * @param targetTab 
	 * 			The tab that this section applies to (must not be null).
	 * @param typeMapper
	 *          The type mapper.
	 */
	protected AbstractSectionDescriptor(String id, String targetTab, ITypeMapper typeMapper) {
		this();
		classFilter = new TabbedPropertyRegistryClassSectionFilter(typeMapper);
		this.id = id;
		this.targetTab = targetTab;

		if (id == null || targetTab == null) {
			// the section id and tab are mandatory - log error
			handleSectionError(null);
		}
	}

	/**
	 * Creates a new section descriptor. It is the resposibility of the subclass to ensure
	 * that at least a valid id and targetTab are set afterwards.
	 * @see #setId(String)
	 * @see #setTargetTab(String)
	 */
	protected AbstractSectionDescriptor() {
		afterSection = TOP;
	}

	/**
	 * Handle the section error when an issue is found loading from the
	 * configuration element.
	 * 
	 * @param exception
	 *            an optional CoreException
	 */
	private void handleSectionError(CoreException exception) {
		String pluginId = TabbedPropertyViewPlugin.getPlugin().getBundle().getSymbolicName(); 
		String message = MessageFormat.format(SECTION_ERROR,
			new Object[] {pluginId});
		IStatus status = new Status(IStatus.ERROR, pluginId,
			TabbedPropertyViewStatusCodes.SECTION_ERROR, message, exception);
		TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getId()
	 */
	public String getId() {
		return id;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getFilter()
	 */
	public IFilter getFilter() {
		return filter;
	}
	
	/**
	 * @param aEnablesFor The enablesFor to set.
	 */
	public void setEnablesFor(int enablesFor) {
		this.enablesFor = enablesFor;
	}
	
	/**
	 * Retrieves the value for section enablement which is a precise number of
	 * items selected. For example: enablesFor=" 4" enables the action only when
	 * 4 items are selected. If not specified, enable for all selections.
	 * 
	 * @return the value for section enablement.
	 */
	public int getEnablesFor() {
		return enablesFor;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getTargetTab()
	 */
	public String getTargetTab() {
		return targetTab;
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#appliesTo(org.eclipse.ui.IWorkbenchPart,
	 *      org.eclipse.jface.viewers.ISelection)
	 */
	public boolean appliesTo(IWorkbenchPart part, ISelection selection) {
		return classFilter.appliesToSelection(this, selection);
	}

	/**
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getAfterSection()
	 */
	public String getAfterSection() {
		return afterSection;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return getId();
	}
	
	/**
	 * @param id The id to set (must not be null).
	 */
	protected void setId(String id) {
		if (id == null) {
			throw new IllegalArgumentException("id must not be null"); //$NON-NLS-1$
		}
		
		this.id = id;
	}
	
	/**
	 * @param targetTab The targetTab to set (must not be null).
	 */
	protected void setTargetTab(String targetTab) {
		if (targetTab == null) {
			throw new IllegalArgumentException("targetTab must not be null"); //$NON-NLS-1$
		}
		this.targetTab = targetTab;
	}
	
	protected void setTypeMapper(ITypeMapper typeMapper) {
		classFilter = new TabbedPropertyRegistryClassSectionFilter(typeMapper);
	}

	/**
	 * @param aAfterSection The afterSection to set.
	 */
	protected void setAfterSection(String afterSection) {
		this.afterSection = afterSection;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getInputTypes()
	 * Returns an empty list by default. Actually only applicable to subclass SectionDescriptor
	 * but already released in ISectionDescriptor
	 */
	public List getInputTypes() {
		return Collections.EMPTY_LIST;
	}
}




/*******************************************************************************
 * Copyright (c) 2001, 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.views.properties.tabbed;



/**
 * A listener interested in tab selection events that occur for the tabbed
 * property sheet page.
 * 
 * @author Anthony Hunter 
 * @version 21 May 2007
 */
public interface ITabSelectionListener2 {

	/**
	 * Notifies this listener that the selected tab has changed.
	 * 
	 * @param tabDescriptor
	 *            the selected tab descriptor.
	 */
	public void tabSelected(ITabDescriptor tabDescriptor);
}




/*******************************************************************************
 * Copyright (c) 2001, 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.views.properties.tabbed;

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;

import com.ibm.icu.text.MessageFormat;

/**
 * Realizes the base implementation of a tab descriptor on the tabbed
 * property tabs extensions.
 * 
 * Clients should subclass this class instead of implementing ITabDescriptor directly. 
 * 
 * The id, label, category and section descriptors properties are mandatory and must not be null.
 * 
 * @author Anthony Hunter
 * @version 31 May 2007
 */
public abstract class AbstractTabDescriptor
	implements Cloneable, ITabItem, ITabDescriptor {

	public static final String TOP = "top"; //$NON-NLS-1$

	private final static String TAB_ERROR = TabbedPropertyMessages.TabDescriptor_Tab_error;

	private String id;

	private String label;

	private Image image;

	private boolean selected;

	private boolean indented;

	private String category;

	private String afterTab;

	private List sectionDescriptors;

	/**
	 * Constructor for AbstractTabDescriptor.
	 * @param id
	 * 			The id of this tab (must not be null)
	 * @param label
	 * 			The label for this tab (must not be null)
	 * @param category
	 * 			The category this tab belongs to (must not be null)
	 */
	protected AbstractTabDescriptor(String id, String label, String category) {
		this();
		
		this.id = id;
		this.label = label;
		this.category = category;
		if (id == null || label == null || category == null) {
			// the tab id, label and category are mandatory - log error
			String pluginId = TabbedPropertyViewPlugin.getPlugin().getBundle().getSymbolicName();
			handleTabError(pluginId, null);
		}
	}

	/**
	 * Creates a new AbstractTabDescriptor.
	 * It is the resposibility of the subclass to ensure
	 * that at least a valid id, label, category a section descriptors are set afterwards.
	 * @see #setId(String)
	 * @see #setCategory(String)
	 * @see #setSectionDescriptors(List)
	 */
	protected AbstractTabDescriptor() {
		afterTab = TOP;
		sectionDescriptors = new ArrayList(5);
		selected = false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#getId()
	 */
	public String getId() {
		return id;
	}

	/**
	 * @param aId The id to set (must not be null).
	 */
	protected void setId(String id) {
		if (id == null) {
			throw new IllegalArgumentException("id must not be null"); //$NON-NLS-1$
		}
		
		this.id = id;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#getLabel()
	 */
	public String getLabel() {
		return label;
	}

	/**
	 * Get the identifier of the tab after which this tab should be displayed.
	 * When two or more tabs belong to the same category, they are sorted by the
	 * after tab values.
	 * 
	 * @return the identifier of the tab.
	 */
	public String getAfterTab() {
		return afterTab;
	}

	/**
	 * Get the category this tab belongs to.
	 * 
	 * @return Get the category this tab belongs to.
	 */
	public String getCategory() {
		return category;
	}

	/**
	 * Returns whether the given section was added to this tab. The section can
	 * be appended if its tab attribute matches the tab id. The afterSection
	 * attribute indicates the order in which the section should be appended.
	 * 
	 * @param target
	 *            the section descriptor to append.
	 */
	public boolean append(ISectionDescriptor target) {
		if (!target.getTargetTab().equals(id)) {
			return false;
		}

		if (insertSectionDescriptor(target)) {
			return true;
		}

		sectionDescriptors.add(target);
		return true;
	}

	/**
	 * Insert the section descriptor into the section descriptor list.
	 * 
	 * @param target
	 *            the section descriptor to insert.
	 * @return <code>true</code> if the target descriptor was added to the
	 *         descriptors list.
	 */
	private boolean insertSectionDescriptor(ISectionDescriptor target) {
		if (target.getAfterSection().equals(TOP)) {
			sectionDescriptors.add(0, target);
			return true;
		}
		for (int i = 0; i < sectionDescriptors.size(); i++) {
			ISectionDescriptor descriptor = (ISectionDescriptor) sectionDescriptors
				.get(i);
			if (target.getAfterSection().equals(descriptor.getId())) {
				sectionDescriptors.add(i + 1, target);
				return true;
			} else {
				if (descriptor.getAfterSection().equals(target.getId())) {
					sectionDescriptors.add(i, target);
					return true;
				}
			}
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#createTab()
	 */
	public TabContents createTab() {
		List sections = new ArrayList(sectionDescriptors.size());
		for (Iterator iter = sectionDescriptors.iterator(); iter.hasNext();) {
			ISectionDescriptor descriptor = (ISectionDescriptor) iter.next();
			ISection section = descriptor.getSectionClass();
			sections.add(section);
		}
		TabContents tab = new TabContents();
		tab.setSections((ISection[]) sections.toArray(new ISection[sections
			.size()]));
		return tab;
	}

	/**
	 * Get the list of section descriptors for the tab.
	 * 
	 * @return the list of section descriptors for the tab.
	 */
	public List getSectionDescriptors() {
		return sectionDescriptors;
	}

	/**
	 * Set the list of section descriptors for the tab.
	 * 
	 * @param sectionDescriptors
	 *            the list of section descriptors for the tab.
	 */
	protected void setSectionDescriptors(List sectionDescriptors) {
		this.sectionDescriptors = sectionDescriptors;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return getId();
	}

	/**
	 * Handle the tab error when an issue is found loading from the
	 * configuration element.
	 * 
	 * @param configurationElement
	 *            the configuration element
	 * @param exception
	 *            an optional CoreException
	 */
	protected void handleTabError(String pluginId, CoreException exception) {
		String message = MessageFormat.format(TAB_ERROR,
			new Object[] {pluginId});
		IStatus status = new Status(IStatus.ERROR, pluginId,
			TabbedPropertyViewStatusCodes.TAB_ERROR, message, exception);
		TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
	}

	/**
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object object) {
		if (this == object) {
			return true;
		}

		if (this.getClass() == object.getClass()) {
			AbstractTabDescriptor descriptor = (AbstractTabDescriptor) object;
			if (this.getCategory().equals(descriptor.getCategory())
				&& this.getId().equals(descriptor.getId())
				&& this.getSectionDescriptors().size() == descriptor
					.getSectionDescriptors().size()) {

				Iterator i = this.getSectionDescriptors().iterator();
				Iterator j = descriptor.getSectionDescriptors().iterator();

				// the order is importent here - so as long as the sizes of the
				// lists are the same and id of the section at the same
				// positions are the same - the lists are the same
				while (i.hasNext()) {
					ISectionDescriptor source = (ISectionDescriptor) i.next();
					ISectionDescriptor target = (ISectionDescriptor) j.next();
					if (!source.getId().equals(target.getId())) {
						return false;
					}
				}

				return true;
			}

		}

		return false;
	}

	/**
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {

		int hashCode = getCategory().hashCode();
		hashCode ^= getId().hashCode();
		Iterator i = this.getSectionDescriptors().iterator();
		while (i.hasNext()) {
			ISectionDescriptor section = (ISectionDescriptor) i.next();
			hashCode ^= section.getId().hashCode();
		}
		return hashCode;
	}

	/**
	 * @see java.lang.Object#clone()
	 */
	public Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException exception) {
			IStatus status = new Status(IStatus.ERROR, TabbedPropertyViewPlugin
				.getPlugin().getBundle().getSymbolicName(), 666, exception
				.getMessage(), exception);
			TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
		}
		return null;
	}

	/**
	 * @param afterTab The id of another tab that should appear before this tab
	 */
	protected void setAfterTab(String afterTab) {
		if (afterTab == null) {
			this.afterTab = TOP;
		} else {
			this.afterTab = afterTab;
		}
	}
	
	/**
	 * @param category The category this tab belongs to (must not be null).
	 */
	protected void setCategory(String category) {
		if (category == null) {
			throw new IllegalArgumentException("category must not be null"); //$NON-NLS-1$
		}
		
		this.category = category;
	}
	
	/**
	 * Set the image for the tab.
	 * 
	 * @param image
	 *            the image for the tab.
	 */
	protected void setImage(Image image) {
		this.image = image;
	}

	/**
	 * Set the indicator to determine if the tab should be displayed as
	 * indented.
	 * 
	 * @param indented
	 *            <code>true</code> if the tab should be displayed as
	 *            indented.
	 */
	protected void setIndented(boolean indented) {
		this.indented = indented;
	}

	/**
	 * Set the indicator to determine if the tab should be the selected tab in
	 * the list.
	 * 
	 * @param selected
	 *            <code>true</code> if the tab should be the selected tab in
	 *            the list.
	 */
	protected void setSelected(boolean selected) {
		this.selected = selected;
	}

	/**
	 * Set the text label for the tab (must not be null).
	 * 
	 * @param label
	 *            the text label for the tab.
	 */
	protected void setLabel(String label) {
		if (label == null) {
			throw new IllegalArgumentException("label must not be null"); //$NON-NLS-1$
		}
		
		this.label = label;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#getImage()
	 */
	public Image getImage() {
		return image;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#isSelected()
	 */
	public boolean isSelected() {
		return selected;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#isIndented()
	 */
	public boolean isIndented() {
		return indented;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.properties.tabbed.view.ITabDescriptor#getText()
	 */
	public String getText() {
		return label;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 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.views.properties.tabbed;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;


/**
 * This interface may be implemented clients who wish to dynamically provide 
 * ITabDescriptors instead of registering them statically with the extension 
 * point org.eclipse.ui.views.properties.tabbed.propertyTabs.
 * The tabbed properties view queries the current selection for instances of
 * this interface, both directly and through the {@link IAdaptable} mechanism.
 * 
 * @since 3.4
 * @version 31 May 2007
 */
public interface ITabDescriptorProvider {
	/**
	 * Returns the descriptors for the tabs to be shown for the given selection.
	 * Note that "this" may actually be part of or derived from the selection.
	 * @return the {@link ITabDescriptor} to be shown in the tabbed properties view
	 * TODO: really pass part and selection? "this" may actually be part of the selection...
	 */
	public ITabDescriptor[] getTabDescriptors(IWorkbenchPart currentPart, ISelection currentSelection);
}




/*******************************************************************************
 * Copyright (c) 2007 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.views.properties.tabbed;

import java.util.List;

import org.eclipse.swt.graphics.Image;

/**
 * <p>
 * Not intended to be implemented by clients. Clients should subclass 
 * <code>AbstractTabDescriptor</code> instead.
 * </p>
 * @since 3.4
 * @version 21 May 2007
 * @see AbstractTabDescriptor
 */
public interface ITabDescriptor {

	/**
	 * Get the unique identifier for the tab.
	 * 
	 * @return the unique identifier for the tab.
	 */
	public String getId();

	/**
	 * Get the text label for the tab.
	 * 
	 * @return the text label for the tab.
	 */
	public String getLabel();

	/**
	 * Instantiate this tab's sections.
	 */
	public TabContents createTab();

	/**
	 * Get the image for the tab.
	 * 
	 * @return the image for the tab.
	 */
	public Image getImage();

	/**
	 * Determine if the tab is selected.
	 * 
	 * @return <code>true</code> if the tab is selected.
	 */
	public boolean isSelected();

	/**
	 * Determine if the tab should be displayed as indented.
	 * 
	 * @return <code>true</code> if the tab should be displayed as indented.
	 */
	public boolean isIndented();

	/**
	 * Get the text label for the tab.
	 * TODO: why getText() and getLabel()?
	 * 
	 * @return the text label for the tab.
	 */
	public String getText();
	
	/**
	 * Get the list of section descriptors for the tab.
	 * 
	 * @return the list of section descriptors for the tab.
	 * TODO: probably arrayify this
	 */
	public List getSectionDescriptors();
	
	/**
	 * Get the category this tab belongs to.
	 * 
	 * @return Get the category this tab belongs to.
	 */
	public String getCategory();
}




/*******************************************************************************
 * Copyright (c) 2007 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.views.properties.tabbed.view;

import java.util.*;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.views.properties.tabbed.AbstractTabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITabDescriptorProvider;


/**
 * Manages {@link ITabDescriptorProvider}s and ensures the correct tab sort order
 * 
 * @since 3.4
 * @version 31 May 2007
 */
public class TabDescriptorProviderManager {

	private List descriptorProviders = new ArrayList();

	/**
	 * Creates a new TabDescriptorProviderManager 
	 */
	public TabDescriptorProviderManager() {
	}

	/**
	 * Inserts a new {@link ITabDescriptorProvider} at the given index
	 * @param index the position where the descriptor should be added
	 * @param provider the provider to add
	 */
	public void insertTabDescriptorProvider(int index, ITabDescriptorProvider provider) {
		descriptorProviders.add(index, provider);
	}
	
	/**
	 * Adds a new {@link ITabDescriptorProvider} to the end of the list
	 * @param provider the provider to add
	 */
	public void addTabDescriptorProvider(ITabDescriptorProvider provider) {
		descriptorProviders.add(provider);
	}
	
	/**
	 * Removes the given provider from the list.
	 * @return Returns true if the provider was previously present in the list
	 */
	public boolean removeTabDescriptorProvider(ITabDescriptorProvider provider) {
		return descriptorProviders.remove(provider);
	}
	
	/**
	 * @return Returns all the providers
	 */
	public ITabDescriptorProvider[] getDescriptorProviders() {
		return (ITabDescriptorProvider[]) descriptorProviders.toArray(new ITabDescriptorProvider[descriptorProviders.size()]);
	}
	
	/**
	 * Returns the {@link ITabDescriptor}s applicable to the IWorkbenchPart and the 
	 * given ISelection. Asks all {@link ITabDescriptorProvider}s as well as 
	 * {@link TabbedPropertyRegistry} and returns their descriptors in the correct sort order
	 * @param currentPart
	 * @param currentSelection
	 * @return all applicable {@link ITabDescriptor}s 
	 */
	public ITabDescriptor[] getTabDescriptors(IWorkbenchPart currentPart, ISelection currentSelection) {
		Set descriptorSet = new HashSet();
		
		// first those from the selection
		for (Iterator iter = getProvidersFromSelection(currentPart, currentSelection).iterator(); iter.hasNext();) {
			ITabDescriptorProvider provider = (ITabDescriptorProvider) iter.next();
			addReplaceDescriptors(descriptorSet, provider.getTabDescriptors(currentPart, currentSelection));
		}
		
		// then the explicitly registered ones (including the registry)
		for (Iterator iter = descriptorProviders.iterator(); iter.hasNext();) {
			ITabDescriptorProvider provider = (ITabDescriptorProvider) iter.next();
			addReplaceDescriptors(descriptorSet, provider.getTabDescriptors(currentPart, currentSelection));
		}
	
		String[] categories = getAllCategories(descriptorSet);
		List sortedDescriptors = new ArrayList(descriptorSet);
		sortedDescriptors = sortTabDescriptorsByCategory(categories, sortedDescriptors);
		sortedDescriptors = sortTabDescriptorsByAfterTab(categories, sortedDescriptors);
		
		return (ITabDescriptor[]) sortedDescriptors.toArray(new ITabDescriptor[sortedDescriptors.size()]);
	}
	
	/**
	 * @param aCurrentPart
	 * @param aCurrentSelection
	 * @return Returns a list of all available {@link ITabDescriptorProvider}s for the given selection
	 * @see #getProviderFor(Object)
	 */
	private List getProvidersFromSelection(IWorkbenchPart currentPart, ISelection currentSelection) {
		if (currentSelection instanceof IStructuredSelection) {
			IStructuredSelection ssel = (IStructuredSelection) currentSelection;
			List result = new ArrayList();
			for (Iterator iter = ssel.iterator(); iter.hasNext();) {
				Object element = iter.next();
				ITabDescriptorProvider provider = getProviderFor(element);
				if (provider != null) {
					result.add(provider);
				}
			}
			
			return result; 
		}
		
		return Collections.EMPTY_LIST;
	}

	/**
	 * Returns an {@link ITabDescriptorProvider} for the given element if available.
	 * Returns the element itself if it is an ITabDescriptorProvider or uses the {@link IAdaptable}
	 * mechanism.   
	 * @param element the element to query an ITabDescriptorProvider for
	 */
	protected ITabDescriptorProvider getProviderFor(Object element) {
		if (element instanceof ITabDescriptorProvider) {
			return (ITabDescriptorProvider) element;
		}
		
		ITabDescriptorProvider provider = null;
		
		if (element instanceof IAdaptable) {
			IAdaptable adaptable = (IAdaptable) element;
			provider = (ITabDescriptorProvider) adaptable.getAdapter(ITabDescriptorProvider.class);
			if (provider != null) {
				return provider;
			}
			
			if (Platform.getAdapterManager().hasAdapter(adaptable, ITabDescriptorProvider.class.getName())) {
				provider = (ITabDescriptorProvider) Platform.getAdapterManager().loadAdapter(adaptable, ITabDescriptorProvider.class.getName());
			}
		}
		
		return provider;
	}

	/**
	 * @param descriptors a set of {@link ITabDescriptor}s
	 * @return Returns all categories referenced by the given set of ITabDescriptors
	 */
	private String[] getAllCategories(Set descriptors) {
		Set allCategories = new HashSet();
		
		for (Iterator iter = descriptors.iterator(); iter.hasNext();) {
			ITabDescriptor descriptor = (ITabDescriptor) iter.next();
			String category = descriptor.getCategory();
			allCategories.add(category);
		}
		
		return (String[]) allCategories.toArray(new String[allCategories.size()]);
	}

	/**
	 * Adds the given descriptors to the set of {@link ITabDescriptor}s. If an equal
	 * descriptor is already in the set, it is replaced.  
	 * @param descriptorSet the Set<ITabDescriptor>
	 * @param descriptors the descriptors to add to the set
	 */
	protected void addReplaceDescriptors(Set descriptorSet, ITabDescriptor[] descriptors) {
		if (descriptors != null) {
			for (int i = 0; i < descriptors.length; i++) {
				descriptorSet.remove(descriptors[i]); // last one takes precedence
				descriptorSet.add(descriptors[i]);
			}
		}
	}
	
	/**
	 * Sorts the tab descriptors in the given list according to category.
	 * @param categories 
	 */
	protected List sortTabDescriptorsByCategory(final String[] categories, List descriptors) {
		Collections.sort(descriptors, new Comparator() {

			public int compare(Object arg0, Object arg1) {
				AbstractTabDescriptor one = (AbstractTabDescriptor) arg0;
				AbstractTabDescriptor two = (AbstractTabDescriptor) arg1;
				String categoryOne = one.getCategory();
				String categoryTwo = two.getCategory();
				int categoryOnePosition = getIndex(categories, categoryOne);
				int categoryTwoPosition = getIndex(categories, categoryTwo);
				return categoryOnePosition - categoryTwoPosition;
			}
		});
		return descriptors;
	}

	/**
	 * Sorts the tab descriptors in the given list according to afterTab.
	 * @param categories 
	 */
	protected List sortTabDescriptorsByAfterTab(String[] categories, List tabs) {
		if (tabs.size() == 0 || categories == null) {
			return tabs;
		}
		List sorted = new ArrayList();
		int categoryIndex = 0;
		for (int i = 0; i < categories.length; i++) {
			List categoryList = new ArrayList();
			String category = categories[i];
			int topOfCategory = categoryIndex;
			int endOfCategory = categoryIndex;
			while (endOfCategory < tabs.size()
				&& ((AbstractTabDescriptor) tabs.get(endOfCategory)).getCategory()
					.equals(category)) {
				endOfCategory++;
			}
			for (int j = topOfCategory; j < endOfCategory; j++) {
				AbstractTabDescriptor tab = (AbstractTabDescriptor) tabs.get(j);
				if (tab.getAfterTab().equals(AbstractTabDescriptor.TOP)) {
					categoryList.add(0, tabs.get(j));
				} else {
					categoryList.add(tabs.get(j));
				}
			}
			Collections.sort(categoryList, new Comparator() {

				public int compare(Object arg0, Object arg1) {
					AbstractTabDescriptor one = (AbstractTabDescriptor) arg0;
					AbstractTabDescriptor two = (AbstractTabDescriptor) arg1;
					if (two.getAfterTab().equals(one.getId())) {
						return -1;
					} else if (one.getAfterTab().equals(two.getId())) {
						return 1;
					} else {
						return 0;
					}
				}
			});
			for (int j = 0; j < categoryList.size(); j++) {
				sorted.add(categoryList.get(j));
			}
			categoryIndex = endOfCategory;
		}
		return sorted;
	}
	
	/**
	 * Returns the index of the given element in the array.
	 */
	private int getIndex(Object[] array, Object target) {
		for (int i = 0; i < array.length; i++) {
			if (array[i].equals(target)) {
				return i;
			}
		}
		return -1; // should never happen
	}
}




import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.views.properties.tabbed.view.Tab;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite;
import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList;
import org.eclipse.ui.tests.views.properties.tabbed.sections.InformationTwoSection;

import org.eclipse.ui.tests.views.properties.tabbed.views.TestsView;
import org.eclipse.ui.tests.views.properties.tabbed.views.TestsViewContentProvider;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.TabContents;

public class TabbedPropertySheetPageTest
    extends TestCase {

         * First tab is Information
         */
        assertEquals(tabbedPropertyList.getElementAt(0).toString(), "Name");//$NON-NLS-1$
        TabContents tab = testsView.getTabbedPropertySheetPage().getCurrentTab();
        /**
         * the tab has two sections.
         */

     * viewer.
     */
    public void test_noPropertiesAvailable() {
        TabContents tab = testsView.getTabbedPropertySheetPage().getCurrentTab();
        assertNull(tab);
        TabbedPropertyList tabbedPropertyList = getTabbedPropertyList();
        assertNull(tabbedPropertyList.getElementAt(0));

Return to bug 131855

Lines 10-16 Link Here

(-)src/org/eclipse/ui/internal/views/properties/tabbed/view/SectionDescriptor.java (-71 / +21 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.internal.views.properties.tabbed.view;	11	package org.eclipse.ui.internal.views.properties.tabbed.view;
12		12
13	import com.ibm.icu.text.MessageFormat;
14	import java.util.ArrayList;	13	import java.util.ArrayList;
15	import java.util.List;	14	import java.util.List;
16		15
Lines 19-42 Link Here
19	import org.eclipse.core.runtime.IStatus;	18	import org.eclipse.core.runtime.IStatus;
20	import org.eclipse.core.runtime.Status;	19	import org.eclipse.core.runtime.Status;
21	import org.eclipse.jface.viewers.IFilter;	20	import org.eclipse.jface.viewers.IFilter;
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.ui.IWorkbenchPart;
24	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;	21	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
25	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;	22	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
26	import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;	23	import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
		24	import org.eclipse.ui.views.properties.tabbed.AbstractSectionDescriptor;
27	import org.eclipse.ui.views.properties.tabbed.ISection;	25	import org.eclipse.ui.views.properties.tabbed.ISection;
28	import org.eclipse.ui.views.properties.tabbed.ISectionDescriptor;
29	import org.eclipse.ui.views.properties.tabbed.ITypeMapper;	26	import org.eclipse.ui.views.properties.tabbed.ITypeMapper;
30		27
		28	import com.ibm.icu.text.MessageFormat;
		29
31	/**	30	/**
32	* Represents the default implementation of a section descriptor on the tabbed	31	* Represents the default implementation of a section descriptor on the tabbed
33	* property sections extensions. This implementation assumes that we are	32	* property sections extensions. This implementation assumes that we are
34	* interested in selected objects in an IStructuredSelection.	33	* interested in selected objects in an IStructuredSelection.
35	*	34	*
36	* @author Anthony Hunter	35	* @author Anthony Hunter
		36	* @version 21 May 2007
37	*/	37	*/
38	public class SectionDescriptor	38	public class SectionDescriptor
39	implements ISectionDescriptor {	39	extends AbstractSectionDescriptor {
40		40
41	private final static String SECTION_ERROR = TabbedPropertyMessages.SectionDescriptor_Section_error;	41	private final static String SECTION_ERROR = TabbedPropertyMessages.SectionDescriptor_Section_error;
42		42
Lines 56-77 Link Here
56		56
57	private static final String ELEMENT_INPUT = "input"; //$NON-NLS-1$	57	private static final String ELEMENT_INPUT = "input"; //$NON-NLS-1$
58		58
59	private static final String TOP = "top"; //$NON-NLS-1$
60
61	private String id;
62
63	private String targetTab;
64
65	private String afterSection;
66
67	private ArrayList inputTypes;	59	private ArrayList inputTypes;
68		60
69	private TabbedPropertyRegistryClassSectionFilter classFilter;
70
71	private IFilter filter;	61	private IFilter filter;
72		62
73	private int enablesFor = ENABLES_FOR_ANY;
74
75	private IConfigurationElement configurationElement;	63	private IConfigurationElement configurationElement;
76		64
77	/**	65	/**
Lines 84-102 Link Here
84	*/	72	*/
85	protected SectionDescriptor(IConfigurationElement configurationElement,	73	protected SectionDescriptor(IConfigurationElement configurationElement,
86	ITypeMapper typeMapper) {	74	ITypeMapper typeMapper) {
		75	super();
		76
87	this.configurationElement = configurationElement;	77	this.configurationElement = configurationElement;
88		78
89	classFilter = new TabbedPropertyRegistryClassSectionFilter(typeMapper);	79	setTypeMapper(typeMapper);
90	id = getConfigurationElement().getAttribute(ATT_ID);	80	String id = getConfigurationElement().getAttribute(ATT_ID);
91	targetTab = getConfigurationElement().getAttribute(ATT_TARGET_TAB);	81	String targetTab = getConfigurationElement().getAttribute(ATT_TARGET_TAB);
92	afterSection = getConfigurationElement()	82	String afterSection = getConfigurationElement()
93	.getAttribute(ATT_AFTER_SECTION);	83	.getAttribute(ATT_AFTER_SECTION);
94	if (getConfigurationElement().getAttribute(ATT_SECTION_ENABLES_FOR) != null) {	84	if (getConfigurationElement().getAttribute(ATT_SECTION_ENABLES_FOR) != null) {
95	String enablesForStr = getConfigurationElement().getAttribute(	85	String enablesForStr = getConfigurationElement().getAttribute(
96	ATT_SECTION_ENABLES_FOR);	86	ATT_SECTION_ENABLES_FOR);
97	int enablesForTest = Integer.parseInt(enablesForStr);	87	int enablesForTest = Integer.parseInt(enablesForStr);
98	if (enablesForTest > 0) {	88	if (enablesForTest > 0) {
99	enablesFor = enablesForTest;	89	setEnablesFor(enablesForTest);
100	}	90	}
101	}	91	}
102		92
Lines 104-111 Link Here
104	// the section id and tab are mandatory - log error	94	// the section id and tab are mandatory - log error
105	handleSectionError(null);	95	handleSectionError(null);
106	}	96	}
107	if (getAfterSection() == null) {	97
108	afterSection = TOP;	98	if (afterSection != null) {
		99	setAfterSection(afterSection);
		100	}
		101	if (id != null) {
		102	setId(id);
		103	}
		104	if (targetTab != null) {
		105	setTargetTab(targetTab);
109	}	106	}
110	}	107	}
111		108
Lines 129-141 Link Here
129	}	126	}
130		127
131	/**	128	/**
132	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getId()
133	*/
134	public String getId() {
135	return id;
136	}
137
138	/**
139	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getFilter()	129	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getFilter()
140	*/	130	*/
141	public IFilter getFilter() {	131	public IFilter getFilter() {
Lines 153-191 Link Here
153	}	143	}
154		144
155	/**	145	/**
156	* Retrieves the value for section enablement which is a precise number of
157	* items selected. For example: enablesFor=" 4" enables the action only when
158	* 4 items are selected. If not specified, enable for all selections.
159	*
160	* @return the value for section enablement.
161	*/
162	public int getEnablesFor() {
163	return enablesFor;
164	}
165
166	/**
167	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getTargetTab()
168	*/
169	public String getTargetTab() {
170	return targetTab;
171	}
172
173	/**
174	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#appliesTo(org.eclipse.ui.IWorkbenchPart,
175	* org.eclipse.jface.viewers.ISelection)
176	*/
177	public boolean appliesTo(IWorkbenchPart part, ISelection selection) {
178	return classFilter.appliesToSelection(this, selection);
179	}
180
181	/**
182	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getAfterSection()
183	*/
184	public String getAfterSection() {
185	return afterSection;
186	}
187
188	/**
189	* Creates an instance of a section described by this descriptor	146	* Creates an instance of a section described by this descriptor
190	*	147	*
191	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getSectionClass()	148	* @see org.eclipse.ui.views.properties.tabbed.ISectionDescriptor#getSectionClass()
Lines 222-234 Link Here
222	}	179	}
223		180
224	/**	181	/**
225	* @see java.lang.Object#toString()
226	*/
227	public String toString() {
228	return getId();
229	}
230
231	/**
232	* @return Returns the configurationElement.	182	* @return Returns the configurationElement.
233	*/	183	*/
234	private IConfigurationElement getConfigurationElement() {	184	private IConfigurationElement getConfigurationElement() {

Lines 10-46 Link Here

(-)src/org/eclipse/ui/internal/views/properties/tabbed/view/TabbedPropertyRegistry.java (-107 / +12 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.internal.views.properties.tabbed.view;	11	package org.eclipse.ui.internal.views.properties.tabbed.view;
12		12
13	import com.ibm.icu.text.MessageFormat;
14	import java.util.ArrayList;	13	import java.util.ArrayList;
15	import java.util.Collections;
16	import java.util.Comparator;
17	import java.util.Iterator;	14	import java.util.Iterator;
18	import java.util.List;	15	import java.util.List;
19		16
20	import org.eclipse.core.runtime.CoreException;	17	import org.eclipse.core.runtime.*;
21	import org.eclipse.core.runtime.IConfigurationElement;
22	import org.eclipse.core.runtime.IExtensionPoint;
23	import org.eclipse.core.runtime.IStatus;
24	import org.eclipse.core.runtime.Platform;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.jface.viewers.ILabelProvider;	18	import org.eclipse.jface.viewers.ILabelProvider;
27	import org.eclipse.jface.viewers.ISelection;	19	import org.eclipse.jface.viewers.ISelection;
28	import org.eclipse.ui.IWorkbenchPart;	20	import org.eclipse.ui.IWorkbenchPart;
29	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;	21	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
30	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;	22	import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes;
31	import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;	23	import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
32	import org.eclipse.ui.views.properties.tabbed.IActionProvider;	24	import org.eclipse.ui.views.properties.tabbed.*;
33	import org.eclipse.ui.views.properties.tabbed.ISectionDescriptor;	25
34	import org.eclipse.ui.views.properties.tabbed.ISectionDescriptorProvider;	26	import com.ibm.icu.text.MessageFormat;
35	import org.eclipse.ui.views.properties.tabbed.ITypeMapper;
36		27
37	/**	28	/**
38	* Provides information about the tabbed property extension points. Each tabbed	29	* Provides information about the tabbed property extension points. Each tabbed
39	* property registry is associated with a unique contributor ID.	30	* property registry is associated with a unique contributor ID.
40	*	31	*
41	* @author Anthony Hunter	32	* @author Anthony Hunter
		33	* @version 22 May 2007
42	*/	34	*/
43	public class TabbedPropertyRegistry {	35	public class TabbedPropertyRegistry implements ITabDescriptorProvider {
44		36
45	private final static String NO_TAB_ERROR = TabbedPropertyMessages.TabbedPropertyRegistry_Non_existing_tab;	37	private final static String NO_TAB_ERROR = TabbedPropertyMessages.TabbedPropertyRegistry_Non_existing_tab;
46		38
Lines 69-76 Link Here
69		61
70	private static final String ATT_ACTION_PROVIDER = "actionProvider"; //$NON-NLS-1$	62	private static final String ATT_ACTION_PROVIDER = "actionProvider"; //$NON-NLS-1$
71		63
72	private static final String TOP = "top"; //$NON-NLS-1$
73
74	protected String contributorId;	64	protected String contributorId;
75		65
76	protected IConfigurationElement contributorConfigurationElement;	66	protected IConfigurationElement contributorConfigurationElement;
Lines 218-246 Link Here
218	}	208	}
219		209
220	/**	210	/**
221	* Returns the index of the given element in the array.
222	*/
223	private int getIndex(Object[] array, Object target) {
224	for (int i = 0; i < array.length; i++) {
225	if (array[i].equals(target)) {
226	return i;
227	}
228	}
229	return -1; // should never happen
230	}
231
232	/**
233	* Returns property tab descriptors for the given contributor id and object	211	* Returns property tab descriptors for the given contributor id and object
234	* input. The descriptors are sorted using the afterPage attribute.	212	* input. The descriptors are sorted using the afterPage attribute.
235	*/	213	*/
236	public TabDescriptor[] getTabDescriptors(IWorkbenchPart part,	214	public ITabDescriptor[] getTabDescriptors(IWorkbenchPart part,
237	ISelection selection) {	215	ISelection selection) {
238	if (selection == null \|\| selection.isEmpty()) {	216	if (selection == null \|\| selection.isEmpty()) {
239	return EMPTY_DESCRIPTOR_ARRAY;	217	return EMPTY_DESCRIPTOR_ARRAY;
240	}	218	}
241		219
242	TabDescriptor[] allDescriptors = getAllTabDescriptors();	220	TabDescriptor[] allDescriptors = getAllTabDescriptors();
243	TabDescriptor[] result = filterTabDescriptors(allDescriptors, part,	221	ITabDescriptor[] result = filterTabDescriptors(allDescriptors, part,
244	selection);	222	selection);
245	return result;	223	return result;
246	}	224	}
Lines 293-302 Link Here
293	if (tabDescriptors == null) {	271	if (tabDescriptors == null) {
294	List temp = readTabDescriptors();	272	List temp = readTabDescriptors();
295	populateWithSectionDescriptors(temp);	273	populateWithSectionDescriptors(temp);
296	temp = sortTabDescriptorsByCategory(temp);	274	tabDescriptors = (TabDescriptor[]) temp.toArray(new TabDescriptor[temp.size()]);
297	temp = sortTabDescriptorsByAfterTab(temp);
298	tabDescriptors = (TabDescriptor[]) temp
299	.toArray(new TabDescriptor[temp.size()]);
300	}	275	}
301	return tabDescriptors;	276	return tabDescriptors;
302	}	277	}
Lines 313-319 Link Here
313	IConfigurationElement[] tabs = extension.getChildren(ELEMENT_TAB);	288	IConfigurationElement[] tabs = extension.getChildren(ELEMENT_TAB);
314	for (int j = 0; j < tabs.length; j++) {	289	for (int j = 0; j < tabs.length; j++) {
315	IConfigurationElement tab = tabs[j];	290	IConfigurationElement tab = tabs[j];
316	TabDescriptor descriptor = new TabDescriptor(tab);	291	ITabDescriptor descriptor = new TabDescriptor(tab);
317	result.add(descriptor);	292	result.add(descriptor);
318	}	293	}
319	}	294	}
Lines 342-348 Link Here
342	protected void appendToTabDescriptor(ISectionDescriptor section,	317	protected void appendToTabDescriptor(ISectionDescriptor section,
343	List aTabDescriptors) {	318	List aTabDescriptors) {
344	for (Iterator i = aTabDescriptors.iterator(); i.hasNext();) {	319	for (Iterator i = aTabDescriptors.iterator(); i.hasNext();) {
345	TabDescriptor tab = (TabDescriptor) i.next();	320	AbstractTabDescriptor tab = (AbstractTabDescriptor) i.next();
346	if (tab.append(section)) {	321	if (tab.append(section)) {
347	return;	322	return;
348	}	323	}
Lines 357-432 Link Here
357	}	332	}
358		333
359	/**	334	/**
360	* Sorts the tab descriptors in the given list according to category.
361	*/
362	protected List sortTabDescriptorsByCategory(List descriptors) {
363	Collections.sort(descriptors, new Comparator() {
364
365	public int compare(Object arg0, Object arg1) {
366	TabDescriptor one = (TabDescriptor) arg0;
367	TabDescriptor two = (TabDescriptor) arg1;
368	String categoryOne = one.getCategory();
369	String categoryTwo = two.getCategory();
370	int categoryOnePosition = getIndex(propertyCategories.toArray(),
371	categoryOne);
372	int categoryTwoPosition = getIndex(propertyCategories.toArray(),
373	categoryTwo);
374	return categoryOnePosition - categoryTwoPosition;
375	}
376	});
377	return descriptors;
378	}
379
380	/**
381	* Sorts the tab descriptors in the given list according to afterTab.
382	*/
383	protected List sortTabDescriptorsByAfterTab(List tabs) {
384	if (tabs.size() == 0 \|\| propertyCategories == null) {
385	return tabs;
386	}
387	List sorted = new ArrayList();
388	int categoryIndex = 0;
389	for (int i = 0; i < propertyCategories.size(); i++) {
390	List categoryList = new ArrayList();
391	String category = (String)propertyCategories.get(i);
392	int topOfCategory = categoryIndex;
393	int endOfCategory = categoryIndex;
394	while (endOfCategory < tabs.size()
395	&& ((TabDescriptor) tabs.get(endOfCategory)).getCategory()
396	.equals(category)) {
397	endOfCategory++;
398	}
399	for (int j = topOfCategory; j < endOfCategory; j++) {
400	TabDescriptor tab = (TabDescriptor) tabs.get(j);
401	if (tab.getAfterTab().equals(TOP)) {
402	categoryList.add(0, tabs.get(j));
403	} else {
404	categoryList.add(tabs.get(j));
405	}
406	}
407	Collections.sort(categoryList, new Comparator() {
408
409	public int compare(Object arg0, Object arg1) {
410	TabDescriptor one = (TabDescriptor) arg0;
411	TabDescriptor two = (TabDescriptor) arg1;
412	if (two.getAfterTab().equals(one.getId())) {
413	return -1;
414	} else if (one.getAfterTab().equals(two.getId())) {
415	return 1;
416	} else {
417	return 0;
418	}
419	}
420	});
421	for (int j = 0; j < categoryList.size(); j++) {
422	sorted.add(categoryList.get(j));
423	}
424	categoryIndex = endOfCategory;
425	}
426	return sorted;
427	}
428
429	/**
430	* Gets the type mapper for the contributor.	335	* Gets the type mapper for the contributor.
431	*	336	*
432	* @return the type mapper for the contributor.	337	* @return the type mapper for the contributor.
Lines 452-459 Link Here
452	public IActionProvider getActionProvider() {	357	public IActionProvider getActionProvider() {
453	return actionProvider;	358	return actionProvider;
454	}	359	}
455
456	/**	360	/**
		361
457	* Sets the section descriptor provider for the contributor.	362	* Sets the section descriptor provider for the contributor.
458	*	363	*
459	* @param sectionDescriptorProvider	364	* @param sectionDescriptorProvider

Lines 29-34 Link Here

(-)src/org/eclipse/ui/internal/views/properties/tabbed/view/TabbedPropertyRegistryClassSectionFilter.java (-2 / +3 lines)
29	* IStructuredSelection and filtering is based on class.	29	* IStructuredSelection and filtering is based on class.
30	*	30	*
31	* @author Anthony Hunter	31	* @author Anthony Hunter
		32	* @version 15 May 2007
32	*/	33	*/
33	public class TabbedPropertyRegistryClassSectionFilter {	34	public class TabbedPropertyRegistryClassSectionFilter {
34		35
Lines 37-43 Link Here
37	/**	38	/**
38	* constructor.	39	* constructor.
39	*/	40	*/
40	protected TabbedPropertyRegistryClassSectionFilter(ITypeMapper typeMapper) {	41	public TabbedPropertyRegistryClassSectionFilter(ITypeMapper typeMapper) {
41	super();	42	super();
42	this.typeMapper = typeMapper;	43	this.typeMapper = typeMapper;
43	}	44	}
Lines 46-52 Link Here
46	* Verifies if the property section extension represented by sectionElement	47	* Verifies if the property section extension represented by sectionElement
47	* applies to the given input.	48	* applies to the given input.
48	*/	49	*/
49	protected boolean appliesToSelection(ISectionDescriptor descriptor,	50	public boolean appliesToSelection(ISectionDescriptor descriptor,
50	ISelection selection) {	51	ISelection selection) {
51		52
52	if (selection instanceof IStructuredSelection	53	if (selection instanceof IStructuredSelection

Removed Link Here

(-)src/org/eclipse/ui/internal/views/properties/tabbed/view/Tab.java (-240 lines)
1	/*******************************************************************************
2	* Copyright (c) 2001, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.internal.views.properties.tabbed.view;
12
13	import org.eclipse.core.runtime.ISafeRunnable;
14	import org.eclipse.core.runtime.Platform;
15	import org.eclipse.jface.viewers.ISelection;
16	import org.eclipse.swt.SWT;
17	import org.eclipse.swt.layout.FillLayout;
18	import org.eclipse.swt.layout.GridData;
19	import org.eclipse.swt.layout.GridLayout;
20	import org.eclipse.swt.widgets.Composite;
21	import org.eclipse.ui.IWorkbenchPart;
22	import org.eclipse.ui.views.properties.tabbed.ISection;
23	import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;
24
25	/**
26	* A property tab is composed by one or more property sections and is used to
27	* categorize sections.
28	*
29	* @author Anthony Hunter
30	*/
31	public class Tab {
32
33	private ISection[] sections;
34
35	private boolean controlsCreated;
36
37	Tab() {
38	controlsCreated = false;
39	}
40
41	/**
42	* Retrieve a numbered index for the section.
43	* @param section the section.
44	* @return the section index.
45	*/
46	public int getSectionIndex(ISection section) {
47	for (int i = 0; i < sections.length; i++) {
48	if (section == sections[i]) {
49	return i;
50	}
51	}
52	return -1;
53	}
54
55	/**
56	* Retrieve the section at a numbered index.
57	* @param i a numbered index.
58	* @return the section.
59	*/
60	public ISection getSectionAtIndex(int i) {
61	if (i >= 0 && i < sections.length) {
62	return sections[i];
63	}
64	return null;
65	}
66
67	/**
68	* Retrieve the sections on the tab.
69	*
70	* @return the sections on the tab.
71	*/
72	public ISection[] getSections() {
73	return sections;
74	}
75
76	/**
77	* Creates page's sections controls.
78	*
79	* @param parent
80	* @param page
81	*/
82	public void createControls(Composite parent,
83	final TabbedPropertySheetPage page) {
84	Composite pageComposite = page.getWidgetFactory().createComposite(
85	parent, SWT.NO_FOCUS);
86	GridLayout layout = new GridLayout();
87	layout.marginWidth = 0;
88	layout.marginHeight = 0;
89	layout.verticalSpacing = 0;
90	pageComposite.setLayout(layout);
91
92	for (int i = 0; i < sections.length; i++) {
93	final ISection section = sections[i];
94	final Composite sectionComposite = page.getWidgetFactory()
95	.createComposite(pageComposite, SWT.NO_FOCUS);
96	sectionComposite.setLayout(new FillLayout());
97	int style = (section.shouldUseExtraSpace()) ? GridData.FILL_BOTH
98	: GridData.FILL_HORIZONTAL;
99	GridData data = new GridData(style);
100	data.heightHint = section.getMinimumHeight();
101	sectionComposite.setLayoutData(data);
102
103	ISafeRunnable runnable = new ISafeRunnable() {
104
105	public void run()
106	throws Exception {
107	section.createControls(sectionComposite, page);
108	}
109
110	public void handleException(Throwable exception) {
111	/* not used */
112	}
113	};
114	Platform.run(runnable);
115	}
116	controlsCreated = true;
117	}
118
119	/**
120	* Dispose of page's sections controls.
121	*/
122	public void dispose() {
123	for (int i = 0; i < sections.length; i++) {
124	final ISection section = sections[i];
125	ISafeRunnable runnable = new ISafeRunnable() {
126
127	public void run()
128	throws Exception {
129	section.dispose();
130	}
131
132	public void handleException(Throwable exception) {
133	/* not used */
134	}
135	};
136	Platform.run(runnable);
137	}
138	}
139
140	/**
141	* Sends the lifecycle event to the page's sections.
142	*/
143	public void aboutToBeShown() {
144	for (int i = 0; i < sections.length; i++) {
145	final ISection section = sections[i];
146	ISafeRunnable runnable = new ISafeRunnable() {
147
148	public void run()
149	throws Exception {
150	section.aboutToBeShown();
151	}
152
153	public void handleException(Throwable exception) {
154	/* not used */
155	}
156	};
157	Platform.run(runnable);
158	}
159	}
160
161	/**
162	* Sends the lifecycle event to the page's sections.
163	*/
164	public void aboutToBeHidden() {
165	for (int i = 0; i < sections.length; i++) {
166	final ISection section = sections[i];
167	ISafeRunnable runnable = new ISafeRunnable() {
168
169	public void run()
170	throws Exception {
171	section.aboutToBeHidden();
172	}
173
174	public void handleException(Throwable exception) {
175	/* not used */
176	}
177	};
178	Platform.run(runnable);
179	}
180	}
181
182	/**
183	* Sets page's sections input objects.
184	*
185	* @param part
186	* @param selection
187	*/
188	public void setInput(final IWorkbenchPart part, final ISelection selection) {
189	for (int i = 0; i < sections.length; i++) {
190	final ISection section = sections[i];
191	ISafeRunnable runnable = new ISafeRunnable() {
192
193	public void run()
194	throws Exception {
195	section.setInput(part, selection);
196	}
197
198	public void handleException(Throwable throwable) {
199	throwable.printStackTrace();
200	}
201	};
202	Platform.run(runnable);
203	}
204	}
205
206	void setSections(ISection[] sections) {
207	this.sections = sections;
208	}
209
210	/**
211	*
212	* @return <code>true</code> if controls have been created.
213	*/
214	public boolean controlsHaveBeenCreated() {
215	return controlsCreated;
216	}
217
218	/**
219	* If controls have been created, refresh all sections on the page.
220	*/
221	public void refresh() {
222	if (controlsCreated) {
223	for (int i = 0; i < sections.length; i++) {
224	final ISection section = sections[i];
225	ISafeRunnable runnable = new ISafeRunnable() {
226
227	public void run()
228	throws Exception {
229	section.refresh();
230	}
231
232	public void handleException(Throwable throwable) {
233	throwable.printStackTrace();
234	}
235	};
236	Platform.run(runnable);
237	}
238	}
239	}
240	}

Added Link Here

(-)src/org/eclipse/ui/views/properties/tabbed/ITabDescriptorProvider.java (+37 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.views.properties.tabbed;
13
14	import org.eclipse.core.runtime.IAdaptable;
15	import org.eclipse.jface.viewers.ISelection;
16	import org.eclipse.ui.IWorkbenchPart;
17
18
19	/**
20	* This interface may be implemented clients who wish to dynamically provide
21	* ITabDescriptors instead of registering them statically with the extension
22	* point org.eclipse.ui.views.properties.tabbed.propertyTabs.
23	* The tabbed properties view queries the current selection for instances of
24	* this interface, both directly and through the {@link IAdaptable} mechanism.
25	*
26	* @since 3.4
27	* @version 31 May 2007
28	*/
29	public interface ITabDescriptorProvider {
30	/**
31	* Returns the descriptors for the tabs to be shown for the given selection.
32	* Note that "this" may actually be part of or derived from the selection.
33	* @return the {@link ITabDescriptor} to be shown in the tabbed properties view
34	* TODO: really pass part and selection? "this" may actually be part of the selection...
35	*/
36	public ITabDescriptor[] getTabDescriptors(IWorkbenchPart currentPart, ISelection currentSelection);
37	}

Lines 22-28 Link Here

(-)src/org/eclipse/ui/tests/views/properties/tabbed/TabbedPropertySheetPageTest.java (-3 / +3 lines)
22	import org.eclipse.ui.IWorkbenchPage;	22	import org.eclipse.ui.IWorkbenchPage;
23	import org.eclipse.ui.IWorkbenchWindow;	23	import org.eclipse.ui.IWorkbenchWindow;
24	import org.eclipse.ui.PlatformUI;	24	import org.eclipse.ui.PlatformUI;
25	import org.eclipse.ui.internal.views.properties.tabbed.view.Tab;
26	import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite;	25	import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite;
27	import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList;	26	import org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList;
28	import org.eclipse.ui.tests.views.properties.tabbed.sections.InformationTwoSection;	27	import org.eclipse.ui.tests.views.properties.tabbed.sections.InformationTwoSection;
Lines 31-36 Link Here
31	import org.eclipse.ui.tests.views.properties.tabbed.views.TestsView;	30	import org.eclipse.ui.tests.views.properties.tabbed.views.TestsView;
32	import org.eclipse.ui.tests.views.properties.tabbed.views.TestsViewContentProvider;	31	import org.eclipse.ui.tests.views.properties.tabbed.views.TestsViewContentProvider;
33	import org.eclipse.ui.views.properties.tabbed.ISection;	32	import org.eclipse.ui.views.properties.tabbed.ISection;
		33	import org.eclipse.ui.views.properties.tabbed.TabContents;
34		34
35	public class TabbedPropertySheetPageTest	35	public class TabbedPropertySheetPageTest
36	extends TestCase {	36	extends TestCase {
Lines 202-208 Link Here
202	* First tab is Information	202	* First tab is Information
203	*/	203	*/
204	assertEquals(tabbedPropertyList.getElementAt(0).toString(), "Name");//$NON-NLS-1$	204	assertEquals(tabbedPropertyList.getElementAt(0).toString(), "Name");//$NON-NLS-1$
205	Tab tab = testsView.getTabbedPropertySheetPage().getCurrentTab();	205	TabContents tab = testsView.getTabbedPropertySheetPage().getCurrentTab();
206	/**	206	/**
207	* the tab has two sections.	207	* the tab has two sections.
208	*/	208	*/
Lines 258-264 Link Here
258	* viewer.	258	* viewer.
259	*/	259	*/
260	public void test_noPropertiesAvailable() {	260	public void test_noPropertiesAvailable() {
261	Tab tab = testsView.getTabbedPropertySheetPage().getCurrentTab();	261	TabContents tab = testsView.getTabbedPropertySheetPage().getCurrentTab();
262	assertNull(tab);	262	assertNull(tab);
263	TabbedPropertyList tabbedPropertyList = getTabbedPropertyList();	263	TabbedPropertyList tabbedPropertyList = getTabbedPropertyList();
264	assertNull(tabbedPropertyList.getElementAt(0));	264	assertNull(tabbedPropertyList.getElementAt(0));