bundles/org.eclipse.ui.views/src/org/eclipse/ui/views/properties/PropertySheetEntry.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2005 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
  *     Gunnar Wagenknecht - fix for bug 21756 [PropertiesView] property view sorting
  *******************************************************************************/

 package org.eclipse.ui.views.properties;

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

 import org.eclipse.core.commands.common.EventManager;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.jface.viewers.CellEditor;
 import org.eclipse.jface.viewers.ICellEditorListener;
 import org.eclipse.jface.viewers.ILabelProvider;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Composite;

 /**
  * <code>PropertySheetEntry</code> is an implementation of
  * <code>IPropertySheetEntry</code> which uses <code>IPropertySource</code>
  * and <code>IPropertyDescriptor</code> to interact with domain model objects.
  * <p>
  * Every property sheet entry has a single descriptor (except the root entry
  * which has none). This descriptor determines what property
  * of its objects it will display/edit.
  * </p>
  * <p>
  * Entries do not listen for changes in their objects. Since there is no
  * restriction on properties being independent, a change in one property
  * may affect other properties. The value of a parent's property may also
  * change. As a result we are forced to refresh the entire entry tree
  * when a property changes value.
  * </p>
  *
  * @since 3.0 (was previously internal)
  */
 public class PropertySheetEntry extends EventManager implements
 		IPropertySheetEntry {

     /**
      * The values we are displaying/editing.
      * These objects repesent the value of one of the
      * properties of the values of our parent entry.
      * Except for the root entry where they represent the
      * input (selected) objects.
      */
     private Object[] values = new Object[0];

     /**
      * The property sources for the values we are displaying/editing.
      */
     private Map sources = new HashMap(0);

     /**
      * The value of this entry is defined as the the first object
      * in its value array or, if that object is an
      * <code>IPropertySource</code>, the value it returns when sent
      * <code>getEditableValue</code>
      */
     private Object editValue;

     private PropertySheetEntry parent;

     private IPropertySourceProvider propertySourceProvider;

     private IPropertyDescriptor descriptor;

     private CellEditor editor;

     private String errorText;

     private PropertySheetEntry[] childEntries = null;

     /**
      * Create the CellEditorListener for this entry. It listens for
      * value changes in the CellEditor, and cancel and finish requests.
      */
     private ICellEditorListener cellEditorListener = new ICellEditorListener() {
         public void editorValueChanged(boolean oldValidState,
                 boolean newValidState) {
             if (!newValidState)
                 // currently not valid so show an error message
                 setErrorText(editor.getErrorMessage());
             else
                 // currently valid
                 setErrorText(null);
         }

         public void cancelEditor() {
             setErrorText(null);
         }

         public void applyEditorValue() {
             PropertySheetEntry.this.applyEditorValue();
         }
     };

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public void addPropertySheetEntryListener(
             IPropertySheetEntryListener listener) {
         addListenerObject(listener);
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public void applyEditorValue() {
         if (editor == null)
             return;

         // Check if editor has a valid value
         if (!editor.isValueValid()) {
             setErrorText(editor.getErrorMessage());
             return;
         }

         setErrorText(null);

         // See if the value changed and if so update
         Object newValue = editor.getValue();
         boolean changed = false;
         if (values.length > 1) {
             changed = true;
         } else if (editValue == null) {
             if (newValue != null)
                 changed = true;
         } else if (!editValue.equals(newValue))
             changed = true;

         // Set the editor value
         if (changed)
             setValue(newValue);
     }

     /**
      * Return the unsorted intersection of all the <code>IPropertyDescriptor</code>s
      * for the objects.
      * @return List
      */
     private List computeMergedPropertyDescriptors() {
         if (values.length == 0)
             return new ArrayList(0);

         IPropertySource firstSource = getPropertySource(values[0]);
         if (firstSource == null) {
             return new ArrayList(0);
         }

         if (values.length == 1) {
             return Arrays.asList(firstSource.getPropertyDescriptors());
         }

         // get all descriptors from each object
         Map[] propertyDescriptorMaps = new Map[values.length];
         for (int i = 0; i < values.length; i++) {
             Object object = values[i];
             IPropertySource source = getPropertySource(object);
             if (source == null) {
                 // if one of the selected items is not a property source
                 // then we show no properties
                 return new ArrayList(0);
             }
             // get the property descriptors keyed by id
             propertyDescriptorMaps[i] = computePropertyDescriptorsFor(source);
         }

         // intersect
         Map intersection = propertyDescriptorMaps[0];
         for (int i = 1; i < propertyDescriptorMaps.length; i++) {
             // get the current ids
             Object[] ids = intersection.keySet().toArray();
             for (int j = 0; j < ids.length; j++) {
                 Object object = propertyDescriptorMaps[i].get(ids[j]);
                 if (object == null
                         ||
                         // see if the descriptors (which have the same id) are compatible
                         !((IPropertyDescriptor) intersection.get(ids[j]))
                                 .isCompatibleWith((IPropertyDescriptor) object))
                     intersection.remove(ids[j]);
             }
         }

         // sorting is handled in the PropertySheetViewer, return unsorted (in the original order)
         ArrayList result = new ArrayList(intersection.size());
         IPropertyDescriptor[] firstDescs = firstSource.getPropertyDescriptors();
         for (int i = 0; i < firstDescs.length; i++) {
             IPropertyDescriptor desc = firstDescs[i];
             if (intersection.containsKey(desc.getId())) {
                 result.add(desc);
             }
         }
         return result;
     }

     /**
      * Returns an map of property descritptors (keyed on id) for the
      * given property source.
      *
      * @param source a property source for which to obtain descriptors
      * @return a table of decriptors keyed on their id
      */
     private Map computePropertyDescriptorsFor(IPropertySource source) {
         IPropertyDescriptor[] descriptors = source.getPropertyDescriptors();
         Map result = new HashMap(descriptors.length * 2 + 1);
         for (int i = 0; i < descriptors.length; i++) {
             result.put(descriptors[i].getId(), descriptors[i]);
         }
         return result;
     }

     /**
      * Create our child entries.
      */
     private void createChildEntries() {
         // get the current descriptors
         List descriptors = computeMergedPropertyDescriptors();

         // rebuild child entries using old when possible
         PropertySheetEntry[] newEntries = new PropertySheetEntry[descriptors.size()];
 		for (int i = 0; i < descriptors.size(); i++) {
             IPropertyDescriptor d = (IPropertyDescriptor) descriptors.get(i);
             // create new entry
             PropertySheetEntry entry = createChildEntry();
 			entry.setDescriptor(d);
             entry.setParent(this);
             entry.setPropertySourceProvider(propertySourceProvider);
             entry.refreshValues();
             newEntries[i] = entry;
         }
         // only assign if successful
         childEntries = newEntries;
     }

 	/**
 	 * Factory method to create a new child <code>PropertySheetEntry</code>
 	 * instance.
 	 * <p>
 	 * Subclasses may overwrite to create new instances of their own class.
 	 * </p>
 	 *
 	 * @return a new <code>PropertySheetEntry</code> instance for the
 	 *         descriptor passed in
      * @since 3.1
 	 */
 	protected PropertySheetEntry createChildEntry() {
 		return new PropertySheetEntry();
 	}

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public void dispose() {
         if (editor != null) {
             editor.dispose();
             editor = null;
         }
         // recursive call to dispose children
         PropertySheetEntry[] entriesToDispose = childEntries;
         childEntries = null;
         if (entriesToDispose != null)
             for (int i = 0; i < entriesToDispose.length; i++) {
                 // an error in a property source may cause refreshChildEntries
                 // to fail. Since the Workbench handles such errors we
                 // can be left in a state where a child entry is null.
                 if (entriesToDispose[i] != null)
                     entriesToDispose[i].dispose();
             }
     }

     /**
      * The child entries of this entry have changed
      * (children added or removed).
      * Notify all listeners of the change.
      */
     private void fireChildEntriesChanged() {
         Object[] array = getListeners();
         for (int i = 0; i < array.length; i++) {
             IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
             listener.childEntriesChanged(this);
         }
     }

     /**
      * The error message of this entry has changed.
      * Notify all listeners of the change.
      */
     private void fireErrorMessageChanged() {
         Object[] array = getListeners();
         for (int i = 0; i < array.length; i++) {
             IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
             listener.errorMessageChanged(this);
         }
     }

     /**
      * The values of this entry have changed.
      * Notify all listeners of the change.
      */
     private void fireValueChanged() {
         Object[] array = getListeners();
         for (int i = 0; i < array.length; i++) {
             IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
             listener.valueChanged(this);
         }
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getCategory() {
         return descriptor.getCategory();
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public IPropertySheetEntry[] getChildEntries() {
         if (childEntries == null)
             createChildEntries();
         return childEntries;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getDescription() {
         return descriptor.getDescription();
     }

     /**
      * Returns the descriptor for this entry.
      *
      * @return the descriptor for this entry
      * @since 3.1 (was previously private)
      */
     protected IPropertyDescriptor getDescriptor() {
         return descriptor;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getDisplayName() {
         return descriptor.getDisplayName();
     }

     /*
      *  (non-Javadoc)
      * @see org.eclipse.ui.views.properties.IPropertySheetEntry#getEditor(org.eclipse.swt.widgets.Composite)
      */
     public CellEditor getEditor(Composite parent) {

         if (editor == null) {
             editor = descriptor.createPropertyEditor(parent);
             if (editor != null) {
                 editor.addListener(cellEditorListener);
             }
         }
         if (editor != null) {
             editor.setValue(editValue);
             setErrorText(editor.getErrorMessage());
         }
         return editor;
     }

     /**
      * Returns the edit value for the object at the given index.
      *
      * @param index the value object index
      * @return the edit value for the object at the given index
      */
     protected Object getEditValue(int index) {
         Object value = values[index];
         IPropertySource source = getPropertySource(value);
         if (source != null) {
             value = source.getEditableValue();
         }
         return value;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getErrorText() {
         return errorText;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getFilters()[] {
         return descriptor.getFilterFlags();
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public Object getHelpContextIds() {
         return descriptor.getHelpContextIds();
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public Image getImage() {
         ILabelProvider provider = descriptor.getLabelProvider();
         if (provider == null)
             return null;
         return provider.getImage(editValue);
     }

     /**
      * Returns the parent of this entry.
      *
      * @return the parent entry, or <code>null</code> if it has no parent
      * @since 3.1
      */
     protected PropertySheetEntry getParent() {
         return parent;
     }

     /**
      * Returns an property source for the given object.
      *
      * @param object an object for which to obtain a property source or
      *  <code>null</code> if a property source is not available
      * @return an property source for the given object
      * @since 3.1 (was previously private)
      */
     protected IPropertySource getPropertySource(Object object) {
         if (sources.containsKey(object))
             return (IPropertySource) sources.get(object);

         IPropertySource result = null;
         if (propertySourceProvider != null)
             result = propertySourceProvider.getPropertySource(object);
         else if (object instanceof IPropertySource)
             result = (IPropertySource) object;
         else if (object instanceof IAdaptable)
             result = (IPropertySource) ((IAdaptable) object)
                     .getAdapter(IPropertySource.class);

         sources.put(object, result);
         return result;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public String getValueAsString() {
         if (editValue == null)
             return "";//$NON-NLS-1$
         ILabelProvider provider = descriptor.getLabelProvider();
         if (provider == null)
             return editValue.toString();
         String text = provider.getText(editValue);
         if(text == null)
         	return "";//$NON-NLS-1$
         return text;
     }

     /**
      * Returns the value objects of this entry.
      *
      * @return the value objects of this entry
      * @since 3.1 (was previously private)
      */
     public Object[] getValues() {
         return values;
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public boolean hasChildEntries() {
         if (childEntries != null && childEntries.length > 0)
             return true;
         // see if we could have entires if we were asked
         return computeMergedPropertyDescriptors().size() > 0;
     }

     /**
      * Update our child entries.
      * This implementation tries to reuse child entries if possible
      * (if the id of the new descriptor matches the descriptor id of the
      * old entry).
      */
     private void refreshChildEntries() {
         if (childEntries == null)
             // no children to refresh
             return;

         // get the current descriptors
         List descriptors = computeMergedPropertyDescriptors();

         // cache old entries by their descriptor id
         Map entryCache = new HashMap(childEntries.length * 2 + 1);
         for (int i = 0; i < childEntries.length; i++) {
             PropertySheetEntry childEntry = childEntries[i];
             if (childEntry != null) {
                 entryCache.put(childEntry.getDescriptor().getId(), childEntry);
             }
         }

         // create a list of entries to dispose
         List entriesToDispose = new ArrayList(Arrays.asList(childEntries));

         // clear the old entries
         this.childEntries = null;

         // rebuild child entries using old when possible
         PropertySheetEntry[] newEntries = new PropertySheetEntry[descriptors.size()];
         boolean entriesChanged = descriptors.size() != entryCache.size();
         for (int i = 0; i < descriptors.size(); i++) {
             IPropertyDescriptor d = (IPropertyDescriptor) descriptors.get(i);
             // see if we have an entry matching this descriptor
             PropertySheetEntry entry = (PropertySheetEntry) entryCache.get(d
                     .getId());
             if (entry != null) {
                 // reuse old entry
                 entry.setDescriptor(d);
                 entriesToDispose.remove(entry);
             } else {
                 // create new entry
                 entry = createChildEntry();
                 entry.setDescriptor(d);
                 entry.setParent(this);
                 entry.setPropertySourceProvider(propertySourceProvider);
                 entriesChanged = true;
             }
             entry.refreshValues();
             newEntries[i] = entry;
         }

         // only assign if successful
         this.childEntries = newEntries;

         if (entriesChanged)
             fireChildEntriesChanged();

         //Dispose of entries which are no longer needed
         for (int i = 0; i < entriesToDispose.size(); i++) {
             ((IPropertySheetEntry) entriesToDispose.get(i)).dispose();
         }
     }

     /**
      * Refresh the entry tree from the root down.
      *
      * @since 3.1 (was previously private)
      */
     protected void refreshFromRoot() {
         if (parent == null)
             refreshChildEntries();
         else
             parent.refreshFromRoot();
     }

     /**
      * Update our value objects.
      * We ask our parent for the property values based on
      * our descriptor.
      */
     private void refreshValues() {
         // get our parent's value objects
         Object[] currentSources = parent.getValues();

         // loop through the objects getting our property value from each
         Object[] newValues = new Object[currentSources.length];
         for (int i = 0; i < currentSources.length; i++) {
             IPropertySource source = parent
                     .getPropertySource(currentSources[i]);
             newValues[i] = source.getPropertyValue(descriptor.getId());
         }

         // set our new values
         setValues(newValues);
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public void removePropertySheetEntryListener(
             IPropertySheetEntryListener listener) {
         removeListenerObject(listener);
     }

     /* (non-Javadoc)
      * Method declared on IPropertySheetEntry.
      */
     public void resetPropertyValue() {
         if (parent == null)
             // root does not have a default value
             return;

         //	Use our parent's values to reset our values.
         boolean change = false;
         Object[] objects = parent.getValues();
         for (int i = 0; i < objects.length; i++) {
             IPropertySource source = getPropertySource(objects[i]);
             if (source.isPropertySet(descriptor.getId())) {
                 // fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=21756
                 if (source instanceof IPropertySource2) {
                     IPropertySource2 extendedSource = (IPropertySource2) source;
                     // continue with next if property is not resettable
                     if (!extendedSource
                             .isPropertyResettable(descriptor.getId()))
                         continue;
                 }
                 source.resetPropertyValue(descriptor.getId());
                 change = true;
             }
         }
         if (change)
             refreshFromRoot();
     }

     /**
      * Set the descriptor.
      * @param newDescriptor
      */
     private void setDescriptor(IPropertyDescriptor newDescriptor) {
         // if our descriptor is changing, we have to get rid
         // of our current editor if there is one
         if (descriptor != newDescriptor && editor != null) {
             editor.dispose();
             editor = null;
         }
         descriptor = newDescriptor;
     }

     /**
      * Set the error text.  This should be set to null when
      * the current value is valid, otherwise it should be
      * set to a error string
      */
     private void setErrorText(String newErrorText) {
         errorText = newErrorText;
         // inform listeners
         fireErrorMessageChanged();
     }

     /**
      * Sets the parent of the entry to be propertySheetEntry.
      * @param propertySheetEntry
      */
     private void setParent(PropertySheetEntry propertySheetEntry) {
         parent = propertySheetEntry;
     }

     /**
      * Sets a property source provider for this entry.
      * This provider is used to obtain an <code>IPropertySource</code>
      * for each of this entries objects. If no provider is
      * set then a default provider is used.
      * @param provider IPropertySourceProvider
      */
     public void setPropertySourceProvider(IPropertySourceProvider provider) {
         propertySourceProvider = provider;
     }

     /**
      * Set the value for this entry.
      * <p>
      * We set the given value as the value for all our value objects.
      * We then call our parent to update the property we represent
      * with the given value.
      * We then trigger a model refresh.
      * <p>
      *
      * @param newValue the new value
      */
     private void setValue(Object newValue) {
         // Set the value
         for (int i = 0; i < values.length; i++) {
             values[i] = newValue;
         }

         // Inform our parent
         parent.valueChanged(this);

         // Refresh the model
         refreshFromRoot();
     }

     /**
      * The <code>PropertySheetEntry</code> implmentation of this
      * method declared on<code>IPropertySheetEntry</code> will
      * obtain an editable value for the given objects and update
      * the child entries.
      * <p>
      * Updating the child entries will typically call this method
      * on the child entries and thus the entire entry tree is updated
      * </p>
      * @param objects the new values for this entry
      */
     public void setValues(Object[] objects) {
         values = objects;
         sources = new HashMap(values.length * 2 + 1);

         if (values.length == 0)
             editValue = null;
         else {
             // set the first value object as the entry's value
             Object newValue = values[0];

             // see if we should convert the value to an editable value
             IPropertySource source = getPropertySource(newValue);
             if (source != null)
                 newValue = source.getEditableValue();
             editValue = newValue;
         }

         // update our child entries
         refreshChildEntries();

         // inform listeners that our value changed
         fireValueChanged();
     }

     /**
      * The value of the given child entry has changed.
      * Therefore we must set this change into our value objects.
      * <p>
      * We must inform our parent so that it can update its value objects
      * </p>
      * <p>
      * Subclasses may override to set the property value in some
      * custom way.
      * </p>
      *
      * @param child the child entry that changed its value
      */
     protected void valueChanged(PropertySheetEntry child) {
         for (int i = 0; i < values.length; i++) {
             IPropertySource source = getPropertySource(values[i]);
             source.setPropertyValue(child.getDescriptor().getId(), child
                     .getEditValue(i));
         }

         // inform our parent
         if (parent != null)
             parent.valueChanged(this);
     }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2005 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
	* Gunnar Wagenknecht - fix for bug 21756 [PropertiesView] property view sorting
	*******************************************************************************/

	package org.eclipse.ui.views.properties;

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

	import org.eclipse.core.commands.common.EventManager;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.jface.viewers.CellEditor;
	import org.eclipse.jface.viewers.ICellEditorListener;
	import org.eclipse.jface.viewers.ILabelProvider;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.widgets.Composite;

	/**
	* <code>PropertySheetEntry</code> is an implementation of
	* <code>IPropertySheetEntry</code> which uses <code>IPropertySource</code>
	* and <code>IPropertyDescriptor</code> to interact with domain model objects.
	* <p>
	* Every property sheet entry has a single descriptor (except the root entry
	* which has none). This descriptor determines what property
	* of its objects it will display/edit.
	* </p>
	* <p>
	* Entries do not listen for changes in their objects. Since there is no
	* restriction on properties being independent, a change in one property
	* may affect other properties. The value of a parent's property may also
	* change. As a result we are forced to refresh the entire entry tree
	* when a property changes value.
	* </p>
	*
	* @since 3.0 (was previously internal)
	*/
	public class PropertySheetEntry extends EventManager implements
	IPropertySheetEntry {

	/**
	* The values we are displaying/editing.
	* These objects repesent the value of one of the
	* properties of the values of our parent entry.
	* Except for the root entry where they represent the
	* input (selected) objects.
	*/
	private Object[] values = new Object[0];

	/**
	* The property sources for the values we are displaying/editing.
	*/
	private Map sources = new HashMap(0);

	/**
	* The value of this entry is defined as the the first object
	* in its value array or, if that object is an
	* <code>IPropertySource</code>, the value it returns when sent
	* <code>getEditableValue</code>
	*/
	private Object editValue;

	private PropertySheetEntry parent;

	private IPropertySourceProvider propertySourceProvider;

	private IPropertyDescriptor descriptor;

	private CellEditor editor;

	private String errorText;

	private PropertySheetEntry[] childEntries = null;

	/**
	* Create the CellEditorListener for this entry. It listens for
	* value changes in the CellEditor, and cancel and finish requests.
	*/
	private ICellEditorListener cellEditorListener = new ICellEditorListener() {
	public void editorValueChanged(boolean oldValidState,
	boolean newValidState) {
	if (!newValidState)
	// currently not valid so show an error message
	setErrorText(editor.getErrorMessage());
	else
	// currently valid
	setErrorText(null);
	}

	public void cancelEditor() {
	setErrorText(null);
	}

	public void applyEditorValue() {
	PropertySheetEntry.this.applyEditorValue();
	}
	};

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public void addPropertySheetEntryListener(
	IPropertySheetEntryListener listener) {
	addListenerObject(listener);
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public void applyEditorValue() {
	if (editor == null)
	return;

	// Check if editor has a valid value
	if (!editor.isValueValid()) {
	setErrorText(editor.getErrorMessage());
	return;
	}

	setErrorText(null);

	// See if the value changed and if so update
	Object newValue = editor.getValue();
	boolean changed = false;
	if (values.length > 1) {
	changed = true;
	} else if (editValue == null) {
	if (newValue != null)
	changed = true;
	} else if (!editValue.equals(newValue))
	changed = true;

	// Set the editor value
	if (changed)
	setValue(newValue);
	}

	/**
	* Return the unsorted intersection of all the <code>IPropertyDescriptor</code>s
	* for the objects.
	* @return List
	*/
	private List computeMergedPropertyDescriptors() {
	if (values.length == 0)
	return new ArrayList(0);

	IPropertySource firstSource = getPropertySource(values[0]);
	if (firstSource == null) {
	return new ArrayList(0);
	}

	if (values.length == 1) {
	return Arrays.asList(firstSource.getPropertyDescriptors());
	}

	// get all descriptors from each object
	Map[] propertyDescriptorMaps = new Map[values.length];
	for (int i = 0; i < values.length; i++) {
	Object object = values[i];
	IPropertySource source = getPropertySource(object);
	if (source == null) {
	// if one of the selected items is not a property source
	// then we show no properties
	return new ArrayList(0);
	}
	// get the property descriptors keyed by id
	propertyDescriptorMaps[i] = computePropertyDescriptorsFor(source);
	}

	// intersect
	Map intersection = propertyDescriptorMaps[0];
	for (int i = 1; i < propertyDescriptorMaps.length; i++) {
	// get the current ids
	Object[] ids = intersection.keySet().toArray();
	for (int j = 0; j < ids.length; j++) {
	Object object = propertyDescriptorMaps[i].get(ids[j]);
	if (object == null
	\|\|
	// see if the descriptors (which have the same id) are compatible
	!((IPropertyDescriptor) intersection.get(ids[j]))
	.isCompatibleWith((IPropertyDescriptor) object))
	intersection.remove(ids[j]);
	}
	}

	// sorting is handled in the PropertySheetViewer, return unsorted (in the original order)
	ArrayList result = new ArrayList(intersection.size());
	IPropertyDescriptor[] firstDescs = firstSource.getPropertyDescriptors();
	for (int i = 0; i < firstDescs.length; i++) {
	IPropertyDescriptor desc = firstDescs[i];
	if (intersection.containsKey(desc.getId())) {
	result.add(desc);
	}
	}
	return result;
	}

	/**
	* Returns an map of property descritptors (keyed on id) for the
	* given property source.
	*
	* @param source a property source for which to obtain descriptors
	* @return a table of decriptors keyed on their id
	*/
	private Map computePropertyDescriptorsFor(IPropertySource source) {
	IPropertyDescriptor[] descriptors = source.getPropertyDescriptors();
	Map result = new HashMap(descriptors.length * 2 + 1);
	for (int i = 0; i < descriptors.length; i++) {
	result.put(descriptors[i].getId(), descriptors[i]);
	}
	return result;
	}

	/**
	* Create our child entries.
	*/
	private void createChildEntries() {
	// get the current descriptors
	List descriptors = computeMergedPropertyDescriptors();

	// rebuild child entries using old when possible
	PropertySheetEntry[] newEntries = new PropertySheetEntry[descriptors.size()];
	for (int i = 0; i < descriptors.size(); i++) {
	IPropertyDescriptor d = (IPropertyDescriptor) descriptors.get(i);
	// create new entry
	PropertySheetEntry entry = createChildEntry();
	entry.setDescriptor(d);
	entry.setParent(this);
	entry.setPropertySourceProvider(propertySourceProvider);
	entry.refreshValues();
	newEntries[i] = entry;
	}
	// only assign if successful
	childEntries = newEntries;
	}

	/**
	* Factory method to create a new child <code>PropertySheetEntry</code>
	* instance.
	* <p>
	* Subclasses may overwrite to create new instances of their own class.
	* </p>
	*
	* @return a new <code>PropertySheetEntry</code> instance for the
	* descriptor passed in
	* @since 3.1
	*/
	protected PropertySheetEntry createChildEntry() {
	return new PropertySheetEntry();
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public void dispose() {
	if (editor != null) {
	editor.dispose();
	editor = null;
	}
	// recursive call to dispose children
	PropertySheetEntry[] entriesToDispose = childEntries;
	childEntries = null;
	if (entriesToDispose != null)
	for (int i = 0; i < entriesToDispose.length; i++) {
	// an error in a property source may cause refreshChildEntries
	// to fail. Since the Workbench handles such errors we
	// can be left in a state where a child entry is null.
	if (entriesToDispose[i] != null)
	entriesToDispose[i].dispose();
	}
	}

	/**
	* The child entries of this entry have changed
	* (children added or removed).
	* Notify all listeners of the change.
	*/
	private void fireChildEntriesChanged() {
	Object[] array = getListeners();
	for (int i = 0; i < array.length; i++) {
	IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
	listener.childEntriesChanged(this);
	}
	}

	/**
	* The error message of this entry has changed.
	* Notify all listeners of the change.
	*/
	private void fireErrorMessageChanged() {
	Object[] array = getListeners();
	for (int i = 0; i < array.length; i++) {
	IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
	listener.errorMessageChanged(this);
	}
	}

	/**
	* The values of this entry have changed.
	* Notify all listeners of the change.
	*/
	private void fireValueChanged() {
	Object[] array = getListeners();
	for (int i = 0; i < array.length; i++) {
	IPropertySheetEntryListener listener = (IPropertySheetEntryListener) array[i];
	listener.valueChanged(this);
	}
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getCategory() {
	return descriptor.getCategory();
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public IPropertySheetEntry[] getChildEntries() {
	if (childEntries == null)
	createChildEntries();
	return childEntries;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getDescription() {
	return descriptor.getDescription();
	}

	/**
	* Returns the descriptor for this entry.
	*
	* @return the descriptor for this entry
	* @since 3.1 (was previously private)
	*/
	protected IPropertyDescriptor getDescriptor() {
	return descriptor;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getDisplayName() {
	return descriptor.getDisplayName();
	}

	/*
	* (non-Javadoc)
	* @see org.eclipse.ui.views.properties.IPropertySheetEntry#getEditor(org.eclipse.swt.widgets.Composite)
	*/
	public CellEditor getEditor(Composite parent) {

	if (editor == null) {
	editor = descriptor.createPropertyEditor(parent);
	if (editor != null) {
	editor.addListener(cellEditorListener);
	}
	}
	if (editor != null) {
	editor.setValue(editValue);
	setErrorText(editor.getErrorMessage());
	}
	return editor;
	}

	/**
	* Returns the edit value for the object at the given index.
	*
	* @param index the value object index
	* @return the edit value for the object at the given index
	*/
	protected Object getEditValue(int index) {
	Object value = values[index];
	IPropertySource source = getPropertySource(value);
	if (source != null) {
	value = source.getEditableValue();
	}
	return value;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getErrorText() {
	return errorText;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getFilters()[] {
	return descriptor.getFilterFlags();
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public Object getHelpContextIds() {
	return descriptor.getHelpContextIds();
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public Image getImage() {
	ILabelProvider provider = descriptor.getLabelProvider();
	if (provider == null)
	return null;
	return provider.getImage(editValue);
	}

	/**
	* Returns the parent of this entry.
	*
	* @return the parent entry, or <code>null</code> if it has no parent
	* @since 3.1
	*/
	protected PropertySheetEntry getParent() {
	return parent;
	}

	/**
	* Returns an property source for the given object.
	*
	* @param object an object for which to obtain a property source or
	* <code>null</code> if a property source is not available
	* @return an property source for the given object
	* @since 3.1 (was previously private)
	*/
	protected IPropertySource getPropertySource(Object object) {
	if (sources.containsKey(object))
	return (IPropertySource) sources.get(object);

	IPropertySource result = null;
	if (propertySourceProvider != null)
	result = propertySourceProvider.getPropertySource(object);
	else if (object instanceof IPropertySource)
	result = (IPropertySource) object;
	else if (object instanceof IAdaptable)
	result = (IPropertySource) ((IAdaptable) object)
	.getAdapter(IPropertySource.class);

	sources.put(object, result);
	return result;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public String getValueAsString() {
	if (editValue == null)
	return "";//$NON-NLS-1$
	ILabelProvider provider = descriptor.getLabelProvider();
	if (provider == null)
	return editValue.toString();
	String text = provider.getText(editValue);
	if(text == null)
	return "";//$NON-NLS-1$
	return text;
	}

	/**
	* Returns the value objects of this entry.
	*
	* @return the value objects of this entry
	* @since 3.1 (was previously private)
	*/
	public Object[] getValues() {
	return values;
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public boolean hasChildEntries() {
	if (childEntries != null && childEntries.length > 0)
	return true;
	// see if we could have entires if we were asked
	return computeMergedPropertyDescriptors().size() > 0;
	}

	/**
	* Update our child entries.
	* This implementation tries to reuse child entries if possible
	* (if the id of the new descriptor matches the descriptor id of the
	* old entry).
	*/
	private void refreshChildEntries() {
	if (childEntries == null)
	// no children to refresh
	return;

	// get the current descriptors
	List descriptors = computeMergedPropertyDescriptors();

	// cache old entries by their descriptor id
	Map entryCache = new HashMap(childEntries.length * 2 + 1);
	for (int i = 0; i < childEntries.length; i++) {
	PropertySheetEntry childEntry = childEntries[i];
	if (childEntry != null) {
	entryCache.put(childEntry.getDescriptor().getId(), childEntry);
	}
	}

	// create a list of entries to dispose
	List entriesToDispose = new ArrayList(Arrays.asList(childEntries));

	// clear the old entries
	this.childEntries = null;

	// rebuild child entries using old when possible
	PropertySheetEntry[] newEntries = new PropertySheetEntry[descriptors.size()];
	boolean entriesChanged = descriptors.size() != entryCache.size();
	for (int i = 0; i < descriptors.size(); i++) {
	IPropertyDescriptor d = (IPropertyDescriptor) descriptors.get(i);
	// see if we have an entry matching this descriptor
	PropertySheetEntry entry = (PropertySheetEntry) entryCache.get(d
	.getId());
	if (entry != null) {
	// reuse old entry
	entry.setDescriptor(d);
	entriesToDispose.remove(entry);
	} else {
	// create new entry
	entry = createChildEntry();
	entry.setDescriptor(d);
	entry.setParent(this);
	entry.setPropertySourceProvider(propertySourceProvider);
	entriesChanged = true;
	}
	entry.refreshValues();
	newEntries[i] = entry;
	}

	// only assign if successful
	this.childEntries = newEntries;

	if (entriesChanged)
	fireChildEntriesChanged();

	//Dispose of entries which are no longer needed
	for (int i = 0; i < entriesToDispose.size(); i++) {
	((IPropertySheetEntry) entriesToDispose.get(i)).dispose();
	}
	}

	/**
	* Refresh the entry tree from the root down.
	*
	* @since 3.1 (was previously private)
	*/
	protected void refreshFromRoot() {
	if (parent == null)
	refreshChildEntries();
	else
	parent.refreshFromRoot();
	}

	/**
	* Update our value objects.
	* We ask our parent for the property values based on
	* our descriptor.
	*/
	private void refreshValues() {
	// get our parent's value objects
	Object[] currentSources = parent.getValues();

	// loop through the objects getting our property value from each
	Object[] newValues = new Object[currentSources.length];
	for (int i = 0; i < currentSources.length; i++) {
	IPropertySource source = parent
	.getPropertySource(currentSources[i]);
	newValues[i] = source.getPropertyValue(descriptor.getId());
	}

	// set our new values
	setValues(newValues);
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public void removePropertySheetEntryListener(
	IPropertySheetEntryListener listener) {
	removeListenerObject(listener);
	}

	/* (non-Javadoc)
	* Method declared on IPropertySheetEntry.
	*/
	public void resetPropertyValue() {
	if (parent == null)
	// root does not have a default value
	return;

	// Use our parent's values to reset our values.
	boolean change = false;
	Object[] objects = parent.getValues();
	for (int i = 0; i < objects.length; i++) {
	IPropertySource source = getPropertySource(objects[i]);
	if (source.isPropertySet(descriptor.getId())) {
	// fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=21756
	if (source instanceof IPropertySource2) {
	IPropertySource2 extendedSource = (IPropertySource2) source;
	// continue with next if property is not resettable
	if (!extendedSource
	.isPropertyResettable(descriptor.getId()))
	continue;
	}
	source.resetPropertyValue(descriptor.getId());
	change = true;
	}
	}
	if (change)
	refreshFromRoot();
	}

	/**
	* Set the descriptor.
	* @param newDescriptor
	*/
	private void setDescriptor(IPropertyDescriptor newDescriptor) {
	// if our descriptor is changing, we have to get rid
	// of our current editor if there is one
	if (descriptor != newDescriptor && editor != null) {
	editor.dispose();
	editor = null;
	}
	descriptor = newDescriptor;
	}

	/**
	* Set the error text. This should be set to null when
	* the current value is valid, otherwise it should be
	* set to a error string
	*/
	private void setErrorText(String newErrorText) {
	errorText = newErrorText;
	// inform listeners
	fireErrorMessageChanged();
	}

	/**
	* Sets the parent of the entry to be propertySheetEntry.
	* @param propertySheetEntry
	*/
	private void setParent(PropertySheetEntry propertySheetEntry) {
	parent = propertySheetEntry;
	}

	/**
	* Sets a property source provider for this entry.
	* This provider is used to obtain an <code>IPropertySource</code>
	* for each of this entries objects. If no provider is
	* set then a default provider is used.
	* @param provider IPropertySourceProvider
	*/
	public void setPropertySourceProvider(IPropertySourceProvider provider) {
	propertySourceProvider = provider;
	}

	/**
	* Set the value for this entry.
	* <p>
	* We set the given value as the value for all our value objects.
	* We then call our parent to update the property we represent
	* with the given value.
	* We then trigger a model refresh.
	* <p>
	*
	* @param newValue the new value
	*/
	private void setValue(Object newValue) {
	// Set the value
	for (int i = 0; i < values.length; i++) {
	values[i] = newValue;
	}

	// Inform our parent
	parent.valueChanged(this);

	// Refresh the model
	refreshFromRoot();
	}

	/**
	* The <code>PropertySheetEntry</code> implmentation of this
	* method declared on<code>IPropertySheetEntry</code> will
	* obtain an editable value for the given objects and update
	* the child entries.
	* <p>
	* Updating the child entries will typically call this method
	* on the child entries and thus the entire entry tree is updated
	* </p>
	* @param objects the new values for this entry
	*/
	public void setValues(Object[] objects) {
	values = objects;
	sources = new HashMap(values.length * 2 + 1);

	if (values.length == 0)
	editValue = null;
	else {
	// set the first value object as the entry's value
	Object newValue = values[0];

	// see if we should convert the value to an editable value
	IPropertySource source = getPropertySource(newValue);
	if (source != null)
	newValue = source.getEditableValue();
	editValue = newValue;
	}

	// update our child entries
	refreshChildEntries();

	// inform listeners that our value changed
	fireValueChanged();
	}

	/**
	* The value of the given child entry has changed.
	* Therefore we must set this change into our value objects.
	* <p>
	* We must inform our parent so that it can update its value objects
	* </p>
	* <p>
	* Subclasses may override to set the property value in some
	* custom way.
	* </p>
	*
	* @param child the child entry that changed its value
	*/
	protected void valueChanged(PropertySheetEntry child) {
	for (int i = 0; i < values.length; i++) {
	IPropertySource source = getPropertySource(values[i]);
	source.setPropertyValue(child.getDescriptor().getId(), child
	.getEditValue(i));
	}

	// inform our parent
	if (parent != null)
	parent.valueChanged(this);
	}
	}