EDIT

         point="eu.etaxonomy.taxeditor.workbench.e4PreferencePages">

      point="eu.etaxonomy.taxeditor.workbench.e4PreferencePages">

import javax.annotation.PostConstruct;

public class DefaultFeatureTreePreferenecs extends CdmPreferencePage {

	@PostConstruct

		if(CdmStore.isActive()) {

		init();

		label.setText("Deafult Feature Tree to be used for textual descriptions");

	public void init() {

import javax.inject.Inject;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import eu.etaxonomy.cdm.model.common.CdmBase;

public abstract class AbstractMatchingPreferences<T extends IdentifiableEntity> extends FieldEditorPreferencePage {

	@Inject

    protected Control createContents(Composite parent) {

        Control contents = super.createContents(parent);

        return contents;

	    if(CdmStore.isActive()) {

	public abstract Class<? extends CdmBase> getType();

		fields = getAllFields(fields, getType());

import eu.etaxonomy.cdm.model.common.CdmBase;

    @Override

    public Class<? extends CdmBase> getType(){

        return TaxonName.class;

    }

import eu.etaxonomy.cdm.model.common.CdmBase;

    @Override

    public Class<? extends CdmBase> getType(){

        return Reference.class;

    }

import eu.etaxonomy.cdm.model.common.CdmBase;

    @Override

    public Class<? extends CdmBase> getType(){

        return TeamOrPersonBase.class;

    }

import javax.annotation.PostConstruct;

import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermEditor;

public abstract class AbstractMenuPreferences<T extends DefinedTermBase> extends CdmPreferencePage implements IConversationEnabled{

	@PostConstruct

		init();

	protected void createAdditionalContent(@SuppressWarnings("unused") Composite container) {

				Command command = commandService.getCommand(DefinedTermEditor.OPEN_COMMAND_ID);

									+ DefinedTermEditor.OPEN_COMMAND_ID);

    public void init() {

	    if(CdmStore.isActive()) {

		if(tableViewer.getTable().getItems().length>0

		        && tableViewer.getCheckedElements().length == 0){

import javax.annotation.PostConstruct;

	@PostConstruct

import javax.annotation.PostConstruct;

    @PostConstruct

public class PresenceAbsenceMenuPreferences extends AbstractMenuPreferences<PresenceAbsenceTerm> {

public class RankMenuPreferences extends AbstractMenuPreferences<Rank> {

Export-Package: com.opcoach.e4.preferences,

 com.opcoach.e4.preferences.handlers,

 eu.etaxonomy.taxeditor.bulkeditor,

               OSGI-INF/l10n/bundle.properties,\

               schema/

        <children xsi:type="menu:HandledMenuItem" xmi:id="_FaGnuSQNEeen_7LZsZSNoA" elementId="org.eclipse.ui.main.menu.window.preferences" label="%command.label.12" command="_gYnhIKnTEeeTAPHmaMLwQQ"/>

    <elements xsi:type="commands:Command" xmi:id="_gYnhIKnTEeeTAPHmaMLwQQ" elementId="eu.etaxonomy.taxeditor.workbench.preferences" commandName="%command.label.12"/>

    <elements xsi:type="commands:Handler" xmi:id="_zP4pcKnQEeeTAPHmaMLwQQ" elementId="com.opcoach.e4.preferences.handlers.E4PreferencesHandler" contributionURI="bundleclass://eu.etaxonomy.taxeditor.workbench/com.opcoach.e4.preferences.handlers.E4PreferencesHandler" command="_gYnhIKnTEeeTAPHmaMLwQQ"/>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="com.opcoach.e4.preferences" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="com.opcoach.e4.preferences" id="e4PreferencePages" name="e4PreferencePages"/>

      </appinfo>

      <documentation>

         [Enter description of this extension point.]

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="page" minOccurs="0" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

                  a fully qualified identifier of the target extension point

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

                  an optional identifier of the extension instance

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

                  an optional name of the extension instance

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="page">

      <annotation>

         <appinfo>

            <meta.element labelAttribute="name"/>

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="id" type="string" use="required">

            <annotation>

               <documentation>

                  a unique name that will be used to identify this page.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string" use="required">

            <annotation>

               <documentation>

                  a translatable name that will be used in the UI for this page.

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

                  a name of the fully qualified class that implements 

<samp>org.eclipse.jface.preference.IPreferencePage</samp>.

IT IS EASYER to extend FieldEditorPreferencePage 

If this class extends directly org.eclipse.jface.preference.FieldEditorPreferencePage preferenceStore is automatically set on it.

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.jface.preference.FieldEditorPreferencePage:"/>

               </appinfo>

            </annotation>

         </attribute>

         <attribute name="category" type="string">

            <annotation>

               <documentation>

                  a path indicating the location of the page in the preference tree. The path may either be a parent node ID or a sequence

     of IDs separated by '/', representing the full path from the root node.

               </documentation>

               <appinfo>

                  <meta.attribute kind="identifier" basedOn="com.opcoach.e4.preferences.e4PreferencePages/page/@id"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="keywordReference">

      <annotation>

         <documentation>

            A reference by a preference page to a keyword. See the keywords extension point.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="id" type="string" use="required">

            <annotation>

               <documentation>

                  The id of the keyword being referred to.

               </documentation>

               <appinfo>

                  <meta.attribute kind="identifier" basedOn="org.eclipse.ui.keywords/keyword/@id"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="com.opcoach.e4.preferences" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="com.opcoach.e4.preferences" id="e4PreferenceStoreProvider" name="e4PreferenceStoreProvider"/>

      </appinfo>

      <documentation>

         This extension point is used to associate a preference store to a plugin. 

You can choose either to implement the IPreferenceStoreProvider interface or to give the ID of the IPreferenceStore to use (stored in the workbench context of your E4 application). 

If this extension point is not used, a default ScopedPreferenceStore will be used for the preference page. 

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="preferenceStoreProvider" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="preferenceStoreProvider">

      <complexType>

         <attribute name="pluginId" type="string" use="required">

            <annotation>

               <documentation>

                  Set here the plugin Id concerned by this extension. 

Must be a valid plugin ID (control will be done at runtime)

               </documentation>

            </annotation>

         </attribute>

         <attribute name="class" type="string">

            <annotation>

               <documentation>

                  Set a class to get the IPreferenceStore for the defined pluginID. 

This parameter is optional if you use the contextId attribute.

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn=":com.opcoach.e4.preferences.IPreferenceStoreProvider"/>

               </appinfo>

            </annotation>

         </attribute>

         <attribute name="idInWorkbenchContext" type="string">

            <annotation>

               <documentation>

                  If no class is defined, you can set here the ID of the IPreferenceStore available in the context. 

This object must be set in the workbenchContext using an Addon for instance, with the following code (in addon): 

@PostContextCreate

public void initMyAddon(IEclipseContext ctx)

{

    IPreferenceStore ps = new ... .  // The code to create your pref store

    ctx.set(ID set in this extension,  ps);

}

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         The definition could be like the following : 

pluginId="yourPluginID"

provider="a class implementing IPreferenceStoreProvider"

Or using the key in context (usefull to share the same preference store between plugins) : 

pluginId="yourPluginID"

keyInContext="the key of the IPreferenceStore stored in context"

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="copyright"/>

      </appinfo>

      <documentation>

         @OPCoach 2014

      </documentation>

   </annotation>

</schema>

/*******************************************************************************

 * Copyright (c) 2014 OPCoach.

 * 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:

 *     OPCoach - initial API and implementation

 *******************************************************************************/

package com.opcoach.e4.preferences;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import javax.inject.Inject;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExtensionRegistry;

import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.e4.core.contexts.ContextInjectionFactory;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.core.di.annotations.Creatable;

import org.eclipse.e4.core.services.contributions.IContributionFactory;

import org.eclipse.e4.core.services.log.Logger;

import org.eclipse.jface.preference.IPreferenceNode;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.preference.PreferenceManager;

import org.eclipse.jface.preference.PreferenceNode;

import org.eclipse.jface.preference.PreferencePage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

@Creatable

public class E4PreferenceRegistry

{

	public static final String PREFS_PAGE_XP = "eu.etaxonomy.taxeditor.workbench.e4PreferencePages"; // $NON-NLS-1$

	public static final String PREF_STORE_PROVIDER = "eu.etaxonomy.taxeditor.workbench.e4PreferenceStoreProvider"; // $NON-NLS-1$

	protected static final String ELMT_PAGE = "page"; // $NON-NLS-1$

	protected static final String ATTR_ID = "id"; // $NON-NLS-1$

	protected static final String ATTR_CATEGORY = "category"; // $NON-NLS-1$

	protected static final String ATTR_CLASS = "class"; // $NON-NLS-1$

	protected static final String ATTR_NAME = "name"; // $NON-NLS-1$

	protected static final String ATTR_PLUGIN_ID = "pluginId"; // $NON-NLS-1$

	protected static final String ATTR_ID_IN_WBCONTEXT = "idInWorkbenchContext"; // $NON-NLS-1$

	@Inject

	protected Logger logger;

	@Inject

	protected IEclipseContext context;

	@Inject

	protected IExtensionRegistry registry;

	private PreferenceManager pm = null;

	// A map of (pluginId, { IPreferenceStoreProvider, or key in wbcontext }

	private Map<String, Object> psProviders;

	public PreferenceManager getPreferenceManager()

	{

		// Remember of the unbounded nodes to order parent pages.

		// Map<category, list of children> (all nodes except root nodes)

		Map<String, Collection<IPreferenceNode>> childrenNodes = new HashMap<String, Collection<IPreferenceNode>>();

		if (pm != null) {

            return pm;

        }

		pm = new PreferenceManager();

		IContributionFactory factory = context.get(IContributionFactory.class);

		for (IConfigurationElement elmt : registry.getConfigurationElementsFor(PREFS_PAGE_XP))

		{

			String bundleId = elmt.getNamespaceIdentifier();

			if (!elmt.getName().equals(ELMT_PAGE))

			{

				logger.warn("unexpected element: {0}", elmt.getName());

				continue;

			} else if (isEmpty(elmt.getAttribute(ATTR_ID)) || isEmpty(elmt.getAttribute(ATTR_NAME)))

			{

				logger.warn("missing id and/or name: {}", bundleId);

				continue;

			}

			PreferenceNode pn = null;

			if (elmt.getAttribute(ATTR_CLASS) != null)

			{

				PreferencePage page = null;

				try

				{

					String prefPageURI = getClassURI(bundleId, elmt.getAttribute(ATTR_CLASS));

					Object object = factory.create(prefPageURI, context);

					if (!(object instanceof PreferencePage))

					{

						logger.error("Expected instance of PreferencePage: {0}", elmt.getAttribute(ATTR_CLASS));

						continue;

					}

					page = (PreferencePage) object;

					setPreferenceStore(bundleId, page);

				} catch (ClassNotFoundException e)

				{

					logger.error(e);

					continue;

				}

				ContextInjectionFactory.inject(page, context);

				if ((page.getTitle() == null || page.getTitle().isEmpty()) && elmt.getAttribute(ATTR_NAME) != null)

				{

					page.setTitle(elmt.getAttribute(ATTR_NAME));

				}

				pn = new PreferenceNode(elmt.getAttribute(ATTR_ID), page);

			} else

			{

				pn = new PreferenceNode(elmt.getAttribute(ATTR_ID), new EmptyPreferencePage(elmt.getAttribute(ATTR_NAME)));

			}

			// Issue 2 : Fix bug on order (see :

			// https://github.com/opcoach/e4Preferences/issues/2)

			// Add only pages at root level and remember of child pages for

			// categories

			String category = elmt.getAttribute(ATTR_CATEGORY);

			if (isEmpty(category))

			{

				pm.addToRoot(pn);

			} else

			{

				/*

				 * IPreferenceNode parent = findNode(pm, category); if (parent

				 * == null) { // No parent found, but may be the extension has

				 * not been read yet. So remember of it unboundedNodes.put(pn,

				 * category); } else { parent.add(pn); }

				 */

				// Check if this category is already registered.

				Collection<IPreferenceNode> children = childrenNodes.get(category);

				if (children == null)

				{

					children = new ArrayList<IPreferenceNode>();

					childrenNodes.put(category, children);

				}

				children.add(pn);

			}

		}

		// Must now bind pages that has not been added in nodes (depends on the

		// preference page read order)

		// Iterate on all possible categories

		Collection<String> categoriesDone = new ArrayList<String>();

		while (!childrenNodes.isEmpty())

		{

			for (String cat : Collections.unmodifiableSet(childrenNodes.keySet()))

			{

				// Is this category already in preference manager ? If not add

				// it later...

				IPreferenceNode parent = findNode(pm, cat);

				if (parent != null)

				{

					// Can add the list of children to this parent page...

					for (IPreferenceNode pn : childrenNodes.get(cat))

					{

						parent.add(pn);

					}

					// Ok This parent page is done. Can remove it from map

					// outside of this loop

					categoriesDone.add(cat);

				}

			}

			for (String keyToRemove : categoriesDone) {

                childrenNodes.remove(keyToRemove);

            }

			categoriesDone.clear();

		}

		return pm;

	}

	private void setPreferenceStore(String bundleId, PreferencePage page)

	{

		// Affect preference store to this page if this is a

		// PreferencePage, else, must manage it internally

		// Set the issue#1 on github :

		// https://github.com/opcoach/e4Preferences/issues/1

		// And manage the extensions of IP

		initialisePreferenceStoreProviders();

		IPreferenceStore store = null;

		// Get the preference store according to policy.

		Object data = psProviders.get(bundleId);

		if (data != null)

		{

			if (data instanceof IPreferenceStore) {

                store = (IPreferenceStore) data;

            } else if (data instanceof IPreferenceStoreProvider) {

                store = ((IPreferenceStoreProvider) data).getPreferenceStore();

            } else if (data instanceof String) {

                store = (IPreferenceStore) context.get((String) data);

            }

		} else

		{

			// Default behavior : create a preference store for this bundle and remember of it

			store = new ScopedPreferenceStore(InstanceScope.INSTANCE, bundleId);

			psProviders.put(bundleId, store);

		}

		if (store != null) {

            page.setPreferenceStore(store);

        } else

		{

			logger.warn("Unable to set the preferenceStore for page " + page.getTitle() + " defined in bundle " + bundleId);

		}

	}

	/** Read the e4PreferenceStoreProvider extension point */

	private void initialisePreferenceStoreProviders()

	{

		if (psProviders == null)

		{

			IContributionFactory factory = context.get(IContributionFactory.class);

			psProviders = new HashMap<String, Object>();

			// Read extensions and fill the map...

			for (IConfigurationElement elmt : registry.getConfigurationElementsFor(PREF_STORE_PROVIDER))

			{

				String declaringBundle = elmt.getNamespaceIdentifier();

				String pluginId = elmt.getAttribute(ATTR_PLUGIN_ID);

				if (isEmpty(pluginId))

				{

					logger.warn("missing plugin Id in extension " + PREF_STORE_PROVIDER + " check the plugin " + declaringBundle);

					continue;

				}

				String classname = elmt.getAttribute(ATTR_CLASS);

				String objectId = elmt.getAttribute(ATTR_ID_IN_WBCONTEXT);

				if ((isEmpty(classname) && isEmpty(objectId)) || (((classname != null) && classname.length() > 0) && ((objectId != null) && objectId.length() > 0)))

				{

					logger.warn("In extension " + PREF_STORE_PROVIDER + " only one of the two attributes (pluginId or idInWorkbenchContext) must be set. Check the plugin "

							+ declaringBundle);

					continue;

				}

				// Ok can now work with data...

				Object data = objectId;

				if (classname != null)

				{

					data = factory.create(classname, context);

					if (!(data instanceof IPreferenceStoreProvider))

					{

						logger.warn("In extension " + PREF_STORE_PROVIDER + " the class must implements IPreferenceStoreProvider. Check the plugin " + declaringBundle);

						continue;

					}

				}

				psProviders.put(pluginId, data);

			}

		}

	}

	private IPreferenceNode findNode(PreferenceManager pm, String categoryId)

	{

		for (Object o : pm.getElements(PreferenceManager.POST_ORDER))

		{

			if (o instanceof IPreferenceNode && ((IPreferenceNode) o).getId().equals(categoryId))

			{

				return (IPreferenceNode) o;

			}

		}

		return null;

	}

	private String getClassURI(String definingBundleId, String spec) throws ClassNotFoundException

	{

		if (spec.startsWith("platform:"))

		{

			return spec;

		} // $NON-NLS-1$

		return "bundleclass://" + definingBundleId + '/' + spec;

	}

	private boolean isEmpty(String value)

	{

		return value == null || value.trim().isEmpty();

	}

	static class EmptyPreferencePage extends PreferencePage

	{

		public EmptyPreferencePage(String title)

		{

			setTitle(title);

			noDefaultAndApplyButton();

		}

		@Override

		protected Control createContents(Composite parent)

		{

			return new Label(parent, SWT.NONE);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2014 OPCoach.

 * 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:

 *     OPCoach - initial API and implementation

 *******************************************************************************/

package com.opcoach.e4.preferences;

import org.eclipse.jface.preference.IPreferenceStore;

/** This interface can be implemented to provide a PreferenceStore for a given plugin. 

 * This associatino must be done in the e4PreferenceStoreProvider extension point. 

 * @author olivier

 *

 */

public interface IPreferenceStoreProvider

{

	/** Must be implemented to return a preference store */

	public IPreferenceStore getPreferenceStore();

}

/*******************************************************************************

 * Copyright (c) 2014 OPCoach.

 * 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:

 *     Eclipse - copy of the implementation coming from jface 

 *******************************************************************************/

package com.opcoach.e4.preferences;

import java.io.IOException;

import org.eclipse.core.commands.common.EventManager;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Plugin;

import org.eclipse.core.runtime.SafeRunner;

import org.eclipse.core.runtime.preferences.DefaultScope;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.IScopeContext;

import org.eclipse.core.runtime.preferences.IEclipsePreferences.INodeChangeListener;

import org.eclipse.core.runtime.preferences.IEclipsePreferences.NodeChangeEvent;

import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;

import org.eclipse.jface.preference.IPersistentPreferenceStore;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jface.util.SafeRunnable;

import org.osgi.service.prefs.BackingStoreException;

/**

 * The ScopedPreferenceStore is an IPreferenceStore that uses the scopes

 * provided in org.eclipse.core.runtime.preferences.

 * <p>

 * A ScopedPreferenceStore does the lookup of a preference based on it's search

 * scopes and sets the value of the preference based on its store scope.

 * </p>

 * <p>

 * The default scope is always included in the search scopes when searching for

 * preference values.

 * </p>

 * 

 * @see org.eclipse.core.runtime.preferences

 * @since 3.1

 */

public class ScopedPreferenceStore extends EventManager implements

		IPreferenceStore, IPersistentPreferenceStore {

	/**

	 * The storeContext is the context where values will stored with the

	 * setValue methods. If there are no searchContexts this will be the search

	 * context. (along with the "default" context)

	 */

	private IScopeContext storeContext;

	/**

	 * The searchContext is the array of contexts that will be used by the get

	 * methods for searching for values.

	 */

	private IScopeContext[] searchContexts;

	/**

	 * A boolean to indicate the property changes should not be propagated.

	 */

	protected boolean silentRunning = false;

	/**

	 * The listener on the IEclipsePreferences. This is used to forward updates

	 * to the property change listeners on the preference store.

	 */

	IEclipsePreferences.IPreferenceChangeListener preferencesListener;

	/**

	 * The default context is the context where getDefault and setDefault

	 * methods will search. This context is also used in the search.

	 */

	private IScopeContext defaultContext = new DefaultScope();

	/**

	 * The nodeQualifer is the string used to look up the node in the contexts.

	 */

	String nodeQualifier;

	/**

	 * The defaultQualifier is the string used to look up the default node.

	 */

	String defaultQualifier;

	/**

	 * Boolean value indicating whether or not this store has changes to be

	 * saved.

	 */

	private boolean dirty;

	/**

	 * Create a new instance of the receiver. Store the values in context in the

	 * node looked up by qualifier. <strong>NOTE:</strong> Any instance of

	 * ScopedPreferenceStore should call

	 * 

	 * @param context

	 *            the scope to store to

	 * @param qualifier

	 *            the qualifier used to look up the preference node

	 * @param defaultQualifierPath

	 *            the qualifier used when looking up the defaults

	 */

	public ScopedPreferenceStore(IScopeContext context, String qualifier,

			String defaultQualifierPath) {

		this(context, qualifier);

		this.defaultQualifier = defaultQualifierPath;

	}

	/**

	 * Create a new instance of the receiver. Store the values in context in the

	 * node looked up by qualifier.

	 * 

	 * @param context

	 *            the scope to store to

	 * @param qualifier

	 *            the qualifer used to look up the preference node

	 */

	public ScopedPreferenceStore(IScopeContext context, String qualifier) {

		storeContext = context;

		this.nodeQualifier = qualifier;

		this.defaultQualifier = qualifier;

		((IEclipsePreferences) getStorePreferences().parent())

				.addNodeChangeListener(getNodeChangeListener());

	}

	/**

	 * Return a node change listener that adds a removes the receiver when nodes

	 * change.

	 * 

	 * @return INodeChangeListener

	 */

	private INodeChangeListener getNodeChangeListener() {

		return new IEclipsePreferences.INodeChangeListener() {

			/*

			 * (non-Javadoc)

			 * 

			 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.INodeChangeListener#added(org.eclipse.core.runtime.preferences.IEclipsePreferences.NodeChangeEvent)

			 */

			public void added(NodeChangeEvent event) {

				if (nodeQualifier.equals(event.getChild().name())

						&& isListenerAttached()) {

					getStorePreferences().addPreferenceChangeListener(

							preferencesListener);

				}

			}

			/*

			 * (non-Javadoc)

			 * 

			 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.INodeChangeListener#removed(org.eclipse.core.runtime.preferences.IEclipsePreferences.NodeChangeEvent)

			 */

			public void removed(NodeChangeEvent event) {

				// Do nothing as there are no events from removed node

			}

		};

	}

	/**

	 * Initialize the preferences listener.

	 */

	private void initializePreferencesListener() {

		if (preferencesListener == null) {

			preferencesListener = new IEclipsePreferences.IPreferenceChangeListener() {

				/*

				 * (non-Javadoc)

				 * 

				 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)

				 */

				public void preferenceChange(PreferenceChangeEvent event) {

					if (silentRunning) {

						return;

					}

					Object oldValue = event.getOldValue();

					Object newValue = event.getNewValue();

					String key = event.getKey();

					if (newValue == null) {

						newValue = getDefault(key, oldValue);

					} else if (oldValue == null) {

						oldValue = getDefault(key, newValue);

					}

					firePropertyChangeEvent(event.getKey(), oldValue, newValue);

				}

			};

			getStorePreferences().addPreferenceChangeListener(

					preferencesListener);

		}

	}

	/**

	 * Does its best at determining the default value for the given key. Checks

	 * the given object's type and then looks in the list of defaults to see if

	 * a value exists. If not or if there is a problem converting the value, the

	 * default default value for that type is returned.

	 * 

	 * @param key

	 *            the key to search

	 * @param obj

	 *            the object who default we are looking for

	 * @return Object or <code>null</code>

	 */

	Object getDefault(String key, Object obj) {

		IEclipsePreferences defaults = getDefaultPreferences();

		if (obj instanceof String) {

			return defaults.get(key, STRING_DEFAULT_DEFAULT);

		} else if (obj instanceof Integer) {

			return new Integer(defaults.getInt(key, INT_DEFAULT_DEFAULT));

		} else if (obj instanceof Double) {

			return new Double(defaults.getDouble(key, DOUBLE_DEFAULT_DEFAULT));

		} else if (obj instanceof Float) {

			return new Float(defaults.getFloat(key, FLOAT_DEFAULT_DEFAULT));

		} else if (obj instanceof Long) {

			return new Long(defaults.getLong(key, LONG_DEFAULT_DEFAULT));

		} else if (obj instanceof Boolean) {

			return defaults.getBoolean(key, BOOLEAN_DEFAULT_DEFAULT) ? Boolean.TRUE

					: Boolean.FALSE;

		} else {

			return null;

		}

	}