Attachment #36537 for bug #132228

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




package org.eclipse.wst.validation.internal;

import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.logging.Level;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jem.util.logger.LogEntry;
import org.eclipse.jem.util.logger.proxy.Logger;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;



		return super.getValidators();
	}

	/*
   * (non-Javadoc)
   * @see org.eclipse.wst.validation.internal.ValidationConfiguration#getDelegatingValidators()
	 */
  public Map getDelegatingValidators() throws InvocationTargetException {
    if (useGlobalPreference()) {
      return ConfigurationManager.getManager().getGlobalConfiguration().getDelegatingValidators();
    }
    return super.getDelegatingValidators();
  }

	/**
	 * @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getEnabledIncrementalValidators(boolean)
	 */


		setEnabledManualValidators(gp.getManualEnabledValidators());
		setEnabledBuildValidators(gp.getBuildEnabledValidators());
    setDelegatingValidators(gp.getDelegatingValidators());
		
		// except for this field, which is unique to the project preferences
		setDoesProjectOverride(getDoesProjectOverrideDefault());

		GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
		setEnabledManualValidators(gp.getManualEnabledValidators());
		setEnabledBuildValidators(gp.getBuildEnabledValidators());
    setDelegatingValidators(gp.getDelegatingValidators());
	}

	/**

		return false;
	}

  public boolean haveDelegatesChanged(Map oldDelegates, boolean allow) throws InvocationTargetException {

    if (super.haveDelegatesChanged(oldDelegates)) {
      return true;
    }

    if (allow) {
      Map projDelegates = super.getDelegatingValidators(); 
      GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
      return gp.haveDelegatesChanged(projDelegates);
    }
      
    return false;
  }


	/**
	 * @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#deserialize(String)

		}
		return super.isDisableAllValidation();
	}	

  public ValidatorDelegateDescriptor getDelegateDescriptor(ValidatorMetaData vmd) throws InvocationTargetException {
    if (useGlobalPreference()) {
      return ConfigurationManager.getManager().getGlobalConfiguration().getDelegateDescriptor(vmd);
    }
    
    return super.getDelegateDescriptor(vmd);
  }
}

Lines 63-72 Link Here

(-)validate/org/eclipse/wst/validation/internal/GlobalConfiguration.java (-1 / +2 lines)
63	_canProjectsOverride = can;	63	_canProjectsOverride = can;
64	}	64	}
65		65
66	public void resetToDefault() {	66	public void resetToDefault() throws InvocationTargetException {
67	setDisableAllValidation(getDisableValidationDefault());	67	setDisableAllValidation(getDisableValidationDefault());
68	setEnabledValidators(getEnabledValidatorsDefault());	68	setEnabledValidators(getEnabledValidatorsDefault());
69	setCanProjectsOverride(getCanProjectsOverrideDefault());	69	setCanProjectsOverride(getCanProjectsOverrideDefault());
		70	setDefaultDelegates(getValidators());
70	}	71	}
71		72
72	/**	73	/**




	public static final int DEPTH_INFINITE = IResource.DEPTH_INFINITE;
	public static final int DEPTH_ZERO = IResource.DEPTH_ZERO;
	/* package */static final String ELEMENT_SEPARATOR = ";"; //$NON-NLS-1$ // separates the name of one IValidator from the next in the list of enabled validators for a project or preference
  static final String DELEGATES_SEPARATOR = "="; //$NON-NLS-1$ // Separates the delegating validator id from the delegate validator id in the list of delegates
	// The following values must match the attributes in the preference marker as shown in
	// plugin.xml
	// Even though the plugin.xml values are not used to create new Preference or Project markers,

	// These are the QualifiedNames used to persist the user's settings.
	/* package */static final String ENABLED_MANUAL_VALIDATORS = "enabledManualValidatorList"; //$NON-NLS-1$ // String
	/* package */static final String ENABLED_BUILD_VALIDATORS = "enabledBuildValidatorList"; //$NON-NLS-1$ // String
  /* package */static final String DELEGATE_VALIDATORS = "delegateValidatorList"; //$NON-NLS-1$ // String
	public static final String J2EE_PLUGIN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$ // For 4.03, this is the plugin id that the validation constants were declared in.
	/* package */static final String MAXNUMMESSAGES = "maxNumMessages"; //$NON-NLS-1$ // integer
	public static final String PLUGIN_ID = ValidationPlugin.PLUGIN_ID;

	/* package */static final QualifiedName USER_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
	/* package */static final QualifiedName USER_MANUAL_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationManualConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
	/* package */static final QualifiedName USER_BUILD_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationBuildConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
  /* package */static final QualifiedName DELEGATES_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationDelegatesConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource

	// Validation message marker constants
	/* package */static final String VALIDATION_MARKER = PLUGIN_ID + ".problemmarker"; //$NON-NLS-1$ // The extension which is used to add validation markers to the task list

Lines 30-35 Link Here

(-)validate/org/eclipse/wst/validation/internal/ValidationConfiguration.java (-4 / +174 lines)
30	import org.eclipse.core.runtime.CoreException;	30	import org.eclipse.core.runtime.CoreException;
31	import org.eclipse.jem.util.logger.LogEntry;	31	import org.eclipse.jem.util.logger.LogEntry;
32	import org.eclipse.jem.util.logger.proxy.Logger;	32	import org.eclipse.jem.util.logger.proxy.Logger;
		33	import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
		34	import org.eclipse.wst.validation.internal.delegates.ValidatorDelegatesRegistry;
33	import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;	35	import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;
34		36
35		37
Lines 49-54 Link Here
49	// disabled.	51	// disabled.
50	protected HashMap manualValidators = null;	52	protected HashMap manualValidators = null;
51	protected HashMap buildValidators = null;	53	protected HashMap buildValidators = null;
		54	private Map _delegatesByTarget = null;
52		55
53	public static String getEnabledElementsAsString(Set elements) {	56	public static String getEnabledElementsAsString(Set elements) {
54	if (elements == null) {	57	if (elements == null) {
Lines 125-130 Link Here
125		128
126	protected ValidationConfiguration() throws InvocationTargetException {	129	protected ValidationConfiguration() throws InvocationTargetException {
127	_validators = new HashMap();	130	_validators = new HashMap();
		131	_delegatesByTarget = new HashMap();
128	}	132	}
129		133
130	protected ValidationConfiguration(IResource resource, ValidatorMetaData[] validators) throws InvocationTargetException {	134	protected ValidationConfiguration(IResource resource, ValidatorMetaData[] validators) throws InvocationTargetException {
Lines 373-379 Link Here
373	}	377	}
374	}	378	}
375		379
376		380	public void setDefaultDelegates(ValidatorMetaData[] vmds) throws InvocationTargetException {
		381	_delegatesByTarget.clear();
		382	for (int i = 0; i < vmds.length; i++) {
		383	ValidatorMetaData vmd = vmds[i];
		384	if (vmd == null) {
		385	continue;
		386	}
		387	String targetID = vmd.getValidatorUniqueName();
		388	String delegateID = ValidatorDelegatesRegistry.getInstance().getDefaultDelegate(targetID);
		389	if (delegateID == null) {
		390	continue;
		391	}
		392	_delegatesByTarget.put(targetID, ValidatorDelegatesRegistry.getInstance().getDefaultDelegate(targetID));
		393	}
		394	}
377		395
378	/**	396	/**
379	* Returns the number of configured validators on the given project or installed validators in	397	* Returns the number of configured validators on the given project or installed validators in
Lines 563-568 Link Here
563	getResource().setPersistentProperty(ConfigurationConstants.USER_PREFERENCE, serialize());	581	getResource().setPersistentProperty(ConfigurationConstants.USER_PREFERENCE, serialize());
564	getResource().setPersistentProperty(ConfigurationConstants.USER_MANUAL_PREFERENCE, serializeManualSetting());	582	getResource().setPersistentProperty(ConfigurationConstants.USER_MANUAL_PREFERENCE, serializeManualSetting());
565	getResource().setPersistentProperty(ConfigurationConstants.USER_BUILD_PREFERENCE, serializeBuildSetting());	583	getResource().setPersistentProperty(ConfigurationConstants.USER_BUILD_PREFERENCE, serializeBuildSetting());
		584	getResource().setPersistentProperty(ConfigurationConstants.DELEGATES_PREFERENCE, serializeDelegatesSetting());
566	} catch (CoreException exc) {	585	} catch (CoreException exc) {
567	throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_SAVE, new String[]{getResource().getName()}));	586	throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_SAVE, new String[]{getResource().getName()}));
568	}	587	}
Lines 719-724 Link Here
719	deserializeManual(storedManualConfiguration);	738	deserializeManual(storedManualConfiguration);
720	String storedBuildConfiguration = resource.getPersistentProperty(ConfigurationConstants.USER_BUILD_PREFERENCE);	739	String storedBuildConfiguration = resource.getPersistentProperty(ConfigurationConstants.USER_BUILD_PREFERENCE);
721	deserializeBuild(storedBuildConfiguration);	740	deserializeBuild(storedBuildConfiguration);
		741	String storedDelegatesConfiguration = resource.getPersistentProperty(ConfigurationConstants.DELEGATES_PREFERENCE);
		742	deserializeDelegates(storedDelegatesConfiguration);
722	} catch (CoreException exc) {	743	} catch (CoreException exc) {
723	throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_RETRIEVE, new String[]{getResource().getName()}));	744	throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_RETRIEVE, new String[]{getResource().getName()}));
724	}	745	}
Lines 748-753 Link Here
748	setEnabledManualValidators(getStringAsEnabledElementsArray(manualValidation));	769	setEnabledManualValidators(getStringAsEnabledElementsArray(manualValidation));
749	}	770	}
750		771
		772	private void deserializeDelegates(String storedConfiguration) throws InvocationTargetException {
		773
		774	if (storedConfiguration == null \|\| storedConfiguration.length() == 0) {
		775	// Assume that the configuration has never been set (new workspace).
		776	resetToDefault();
		777	return;
		778	}
		779
		780	int delegatesIndex = storedConfiguration.indexOf(ConfigurationConstants.DELEGATE_VALIDATORS);
		781
		782	String delegates = storedConfiguration.substring(delegatesIndex + ConfigurationConstants.DELEGATE_VALIDATORS.length(),storedConfiguration.length());
		783
		784	if (delegates == null) {
		785	return;
		786	}
		787
		788	StringTokenizer tokenizer = new StringTokenizer(delegates, ConfigurationConstants.ELEMENT_SEPARATOR);
		789	while (tokenizer.hasMoreTokens()) {
		790	String delegateConfiguration = tokenizer.nextToken();
		791	int separatorIndex = delegateConfiguration.indexOf(ConfigurationConstants.DELEGATES_SEPARATOR);
		792	String targetID = delegateConfiguration.substring(0, separatorIndex);
		793	String delegateID = delegateConfiguration.substring(separatorIndex + 1);
		794	_delegatesByTarget.put(targetID, delegateID);
		795	}
		796	}
		797
751	protected void copyTo(ValidationConfiguration up) throws InvocationTargetException {	798	protected void copyTo(ValidationConfiguration up) throws InvocationTargetException {
752	up.setVersion(getVersion());	799	up.setVersion(getVersion());
753	up.setResource(getResource());	800	up.setResource(getResource());
Lines 756-764 Link Here
756	up.setEnabledValidators(getEnabledValidators());	803	up.setEnabledValidators(getEnabledValidators());
757	up.setEnabledManualValidators(getManualEnabledValidators());	804	up.setEnabledManualValidators(getManualEnabledValidators());
758	up.setEnabledBuildValidators(getBuildEnabledValidators());	805	up.setEnabledBuildValidators(getBuildEnabledValidators());
		806	up.setDelegatingValidators(getDelegatingValidators());
759	}	807	}
760		808
761	/**	809	public Map getDelegatingValidators() throws InvocationTargetException {
		810	return _delegatesByTarget;
		811	}
		812
		813	public void setDelegatingValidators(Map source)
		814	{
		815	// It is safe to copy this map as it contains only immutable strings.
		816	_delegatesByTarget.putAll(source);
		817	}
		818
		819	/**
762	* Return true if the enabled validators have not changed since this ValidationConfiguration was	820	* Return true if the enabled validators have not changed since this ValidationConfiguration was
763	* constructed, false otherwise. (This method is needed for the Properties and Preference pages;	821	* constructed, false otherwise. (This method is needed for the Properties and Preference pages;
764	* if the list of validators hasn't changed, then there is no need to update the task list;	822	* if the list of validators hasn't changed, then there is no need to update the task list;
Lines 787-792 Link Here
787		845
788	return false;	846	return false;
789	}	847	}
		848
		849	/**
		850	* Determines if there has been a change in the list of delegate validators.
		851	* @param oldDelegates a Map with the old delegates ID by target ID.
		852	* @return true if there has been a change, false otherwise.
		853	* @throws InvocationTargetException
		854	*/
		855	protected boolean haveDelegatesChanged(Map oldDelegates) throws InvocationTargetException {
		856
		857	if (oldDelegates == null) {
		858	return true;
		859	}
		860
		861	Iterator iterator = oldDelegates.keySet().iterator();
		862
		863	while (iterator.hasNext())
		864	{
		865	String targetID = (String) iterator.next();
		866	String oldDelegateID = (String) oldDelegates.get(targetID);
		867	String newDelegateID = (String) _delegatesByTarget.get(targetID);
		868
		869	if (oldDelegateID == null \|\| newDelegateID == null) {
		870	return true;
		871	}
		872
		873	if (!newDelegateID.equals(oldDelegateID)) {
		874	return true;
		875	}
		876	}
		877
		878	if (oldDelegates.size() != _delegatesByTarget.size()) {
		879	return true;
		880	}
		881
		882	return false;
		883	}
790		884
791	protected String serialize() throws InvocationTargetException {	885	protected String serialize() throws InvocationTargetException {
792	StringBuffer buffer = new StringBuffer();	886	StringBuffer buffer = new StringBuffer();
Lines 811-817 Link Here
811	return buffer.toString();	905	return buffer.toString();
812	}	906	}
813		907
814	/**	908	protected String serializeDelegatesSetting() throws InvocationTargetException {
		909	StringBuffer buffer = new StringBuffer();
		910	buffer.append(ConfigurationConstants.DELEGATE_VALIDATORS);
		911	buffer.append(getDelegatesAsString(getValidatorMetaData()));
		912	return buffer.toString();
		913	}
		914
		915	/**
		916	* Provides a String which contains pairs of targetID=delegateID separated by a semicolon.
		917	* @param validatorMetaData a Map with the currently configured validators.
		918	* @return a String.
		919	*/
		920	private String getDelegatesAsString(Map validatorMetaData) {
		921
		922	StringBuffer buffer = new StringBuffer();
		923	Iterator iterator = validatorMetaData.keySet().iterator();
		924
		925	while (iterator.hasNext()) {
		926
		927	ValidatorMetaData vmd = (ValidatorMetaData) iterator.next();
		928	String targetID = vmd.getValidatorUniqueName();
		929	String delegateID = getDelegateUniqueName(vmd);
		930
		931	if (delegateID == null) {
		932	continue;
		933	}
		934
		935	// Write out pairs targetID=delegateID
		936
		937	buffer.append(targetID);
		938	buffer.append(ConfigurationConstants.DELEGATES_SEPARATOR);
		939	buffer.append(delegateID);
		940	buffer.append(ConfigurationConstants.ELEMENT_SEPARATOR);
		941	}
		942
		943	return buffer.toString();
		944	}
		945
		946	/**
		947	* Provides the delegate's ID of the validator delegate configured in this configuration for
		948	* a given delegating validator.
		949	*
		950	* @param vmd the delegating validator's metadata. Must not be null.
		951	* @return a String with the unique name (ID) of the validator delegate, null if there isn't one.
		952	*/
		953	public String getDelegateUniqueName(ValidatorMetaData vmd) {
		954	String targetID = vmd.getValidatorUniqueName();
		955	return (String) _delegatesByTarget.get(targetID);
		956	}
		957
		958	/**
		959	* Sets the delegate's ID of the validator delegate to be used in this configuration for the
		960	* given delegating validator.
		961	*
		962	* @param vmd the delegating validator's metadata. Must not be null.
		963	* @param delegateID a String with the unique name (ID) of the validator delegate. Must not be null.
		964	*/
		965	public void setDelegateUniqueName(ValidatorMetaData vmd, String delegateID) {
		966	String targetID = vmd.getValidatorUniqueName();
		967	_delegatesByTarget.put(targetID, delegateID);
		968	}
		969
		970	/**
815	* Deserialize everything except the version number; the version is deserialized first, in the	971	* Deserialize everything except the version number; the version is deserialized first, in the
816	* loadVersion() method.	972	* loadVersion() method.
817	*/	973	*/
Lines 874-878 Link Here
874		1030
875	public int numberOfManualEnabledValidators() throws InvocationTargetException {	1031	public int numberOfManualEnabledValidators() throws InvocationTargetException {
876	return getManualEnabledValidators().length;	1032	return getManualEnabledValidators().length;
877	}	1033	}
		1034
		1035	/**
		1036	* Provides the delegate validator descriptor of the validator delegate configured
		1037	* for the given delegating validator in the context of this configuration.
		1038	* @param vmd the delegating validator's meta data. Must not be null.
		1039	* @return a ValidatorDelegateDescriptor for the given delegating validator.
		1040	*/
		1041	public ValidatorDelegateDescriptor getDelegateDescriptor(ValidatorMetaData vmd) throws InvocationTargetException {
		1042	String targetID = vmd.getValidatorUniqueName();
		1043	String delegateID = getDelegateUniqueName(vmd);
		1044
		1045	ValidatorDelegateDescriptor descriptor = ValidatorDelegatesRegistry.getInstance().getDescriptor(targetID, delegateID);
		1046	return descriptor;
		1047	}
878	}	1048	}

Lines 7-13 Link Here

(-)plugin.xml (-1 / +2 lines)
7	<extension-point id="validator" name="%Validator" schema="xsds/validatorExtSchema.exsd"/>	7	<extension-point id="validator" name="%Validator" schema="xsds/validatorExtSchema.exsd"/>
8	<extension-point id="referencialFileValidator" name="%ReferencialFileValidator" schema="xsds/referencialFileExtSchema.exsd"/>	8	<extension-point id="referencialFileValidator" name="%ReferencialFileValidator" schema="xsds/referencialFileExtSchema.exsd"/>
9	<extension-point id="validationSelectionHandler" name="%validationSelectionHandler" schema="xsds/validationSelectionHandler.exsd"/>	9	<extension-point id="validationSelectionHandler" name="%validationSelectionHandler" schema="xsds/validationSelectionHandler.exsd"/>
10	<extension-point id="validationHelper" name="validationHelper" schema="xsds/validationHelper.exsd"/>	10	<extension-point id="validationHelper" name="validationHelper" schema="xsds/validationHelper.exsd"/>
		11	<extension-point id="validatorDelegates" name="%ValidatorDelegates" schema="xsds/validatorDelegates.exsd"/>
11		12
12	<!--============================-->	13	<!--============================-->
13	<!-- Validation Contributions -->	14	<!-- Validation Contributions -->

Lines 17-20 Link Here

(-)plugin.properties (-1 / +2 lines)
17	VALIDATION_PREFERENCEMARKER_NAME=Validation Preferences	17	VALIDATION_PREFERENCEMARKER_NAME=Validation Preferences
18	Validator=Validator	18	Validator=Validator
19	ReferencialFileValidator=ReferencialFileValidator	19	ReferencialFileValidator=ReferencialFileValidator
20	validationSelectionHandler=validationSelectionHandler	20	validationSelectionHandler=validationSelectionHandler
		21	ValidatorDelegates=Validator Delegates

Lines 13-19 Link Here

(-)validate/org/eclipse/wst/validation/internal/operations/IWorkbenchContext.java (-2 / +2 lines)
13	import org.eclipse.core.resources.IFile;	13	import org.eclipse.core.resources.IFile;
14	import org.eclipse.core.resources.IProject;	14	import org.eclipse.core.resources.IProject;
15	import org.eclipse.core.resources.IResource;	15	import org.eclipse.core.resources.IResource;
16	import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;	16	import org.eclipse.wst.validation.internal.provisional.core.IProjectValidationContext;
17		17
18		18
19		19
Lines 23-29 Link Here
23	* also needs to load items from the eclipse workbench. This interface should be extended by	23	* also needs to load items from the eclipse workbench. This interface should be extended by
24	* workbench IHelpers, so that items can be added to, and from, the task list.	24	* workbench IHelpers, so that items can be added to, and from, the task list.
25	*/	25	*/
26	public interface IWorkbenchContext extends IValidationContext {	26	public interface IWorkbenchContext extends IProjectValidationContext {
27	/**	27	/**
28	* When the validation is complete, this method will be called so that the IWorkbenchContext can	28	* When the validation is complete, this method will be called so that the IWorkbenchContext can
29	* clean up any resources it allocated during the validation.	29	* clean up any resources it allocated during the validation.

Lines 8-13 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.wst.validation.internal;x-internal:=true,	9	Export-Package: org.eclipse.wst.validation.internal;x-internal:=true,
10	org.eclipse.wst.validation.internal.core;x-internal:=true,	10	org.eclipse.wst.validation.internal.core;x-internal:=true,
		11	org.eclipse.wst.validation.internal.delegates;x-internal:=true,
11	org.eclipse.wst.validation.internal.operations;x-internal:=true,	12	org.eclipse.wst.validation.internal.operations;x-internal:=true,
12	org.eclipse.wst.validation.internal.plugin;x-internal:=true,	13	org.eclipse.wst.validation.internal.plugin;x-internal:=true,
13	org.eclipse.wst.validation.internal.provisional;x-internal:=true,	14	org.eclipse.wst.validation.internal.provisional;x-internal:=true,




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.wst.validation">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.wst.validation" id="validatorDelegates" name="Validator Delegates"/>
      </appInfo>
      <documentation>
         This extension point allows validator providers to contribute alternate implementations for a delegating validator.
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence>
            <element ref="delegate"/>
         </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="delegate">
      <annotation>
         <documentation>
            Defines a validator delegate. Delegating validators can have one or more delegates registered, only one of which can be active (selected) at once.
         </documentation>
      </annotation>
      <complexType>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  Specifies the class name of the delegate validator. The class must implement IValidator.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.wst.validation.internal.provisional.core.IValidator"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="target" type="string" use="required">
            <annotation>
               <documentation>
                  Specifies the id of the validator extension for which this delegate is being registered.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.&lt;/b&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         &lt;extension point=&quot;org.eclipse.wst.validation.validatorDelegates&quot;&gt;
    &lt;delegate
          class=&quot;com.acme.fast.SuperFastValidator&quot;
          name=&quot;Super fast validator&quot;
          target=&quot;org.acme.core.ACMEDelegatingValidator&quot;/&gt;
 &lt;/extension&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         A delegate validator will have to implement the IValidator interface.
The target validator, the one who will delegate its implementation to a delegate validator will have to extend org.eclipse.wst.validation.delegates.BaseDelegatingValidator.
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2006 IBM Corporation and others.&lt;br&gt;
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 &lt;a
href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
      </documentation>
   </annotation>

</schema>




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

package org.eclipse.wst.validation.internal.delegates;

import org.eclipse.wst.validation.internal.provisional.core.IValidator;

/**
 * A delegating validator delegates the actual validation work to a delegate
 * validator. This is a marker interface used internally by the framework to
 * determine if a delegate is a delegating validator.
 * 
 * [Issue] Could/should this interface be replaced with an attribute on the
 * validators extension definition?
 * 
 * <p>
 * <b>Note:</b> This class/interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is being made available at this early stage to solicit feedback
 * from pioneering adopters on the understanding that any code that uses this
 * API will almost certainly be broken (repeatedly) as the API evolves.
 * </p>
 */
public interface IDelegatingValidator extends IValidator
{
}




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

package org.eclipse.wst.validation.internal.delegates;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;

/**
 * This class reads the plugin extension registry and registers each delegating
 * validator descriptor with the delegates registry.
 * 
 * @see ValidatorDelegatesRegistry
 */
class ValidatorDelegatesRegistryReader
{
  /**
   * The delegate class attribute. Must be visible in the package because it is
   * used by other classes in the package.
   */
  static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$

  /**
   * The delegate element name.
   */
  private static final String DELEGATE_ELEMENT = "delegate"; //$NON-NLS-1$

  /**
   * The validator delegates extension point id.
   */
  private static final String EXTENSION_POINT_ID = "validatorDelegates"; //$NON-NLS-1$

  /**
   * The delegate name attribute.
   */
  private static final String NAME_ATTRIBUTE = "name"; //$NON-NLS-1$

  /**
   * Plugin id.
   */
  private static final String PLUGIN_ID = "org.eclipse.wst.validation"; //$NON-NLS-1$

  /**
   * The target id attribute name.
   */
  private static final String TARGET_ATTRIBUTE = "target"; //$NON-NLS-1$

  /**
   * The validator registry where the descriptors being read will be placed.
   */
  private ValidatorDelegatesRegistry registry;

  /**
   * Constructor.
   * 
   * @param registry
   *          the registry where the descriptors being read will be placed.
   */
  public ValidatorDelegatesRegistryReader(ValidatorDelegatesRegistry registry)
  {
    this.registry = registry;
  }

  /**
   * Reads a configuration element.
   * 
   * @param element
   *          the platform configuration element being read.
   */
  private void readElement(IConfigurationElement element)
  {
    String elementName = element.getName();

    if (elementName.equals(DELEGATE_ELEMENT))
    {
      String delegateID = (String) element.getAttribute(CLASS_ATTRIBUTE);
      String delegateName = (String) element.getAttribute(NAME_ATTRIBUTE);
      String targetValidatorID = (String) element.getAttribute(TARGET_ATTRIBUTE);

      ValidatorDelegateDescriptor descriptor = new ValidatorDelegateDescriptor(delegateID, element, delegateName, targetValidatorID);

      registry.add(descriptor);
    }
  }

  /**
   * Read from the extensions registry and parse it.
   */
  void readRegistry()
  {
    IExtensionRegistry pluginRegistry = Platform.getExtensionRegistry();
    IExtensionPoint point = pluginRegistry.getExtensionPoint(PLUGIN_ID, EXTENSION_POINT_ID);

    if (point != null)
    {
      IConfigurationElement[] elements = point.getConfigurationElements();

      for (int index = 0; index < elements.length; index++)
      {
        readElement(elements[index]);
      }
    }
  }
}




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

package org.eclipse.wst.validation.internal.delegates;

import java.lang.reflect.InvocationTargetException;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.wst.validation.internal.ConfigurationManager;
import org.eclipse.wst.validation.internal.ProjectConfiguration;
import org.eclipse.wst.validation.internal.ValidationRegistryReader;
import org.eclipse.wst.validation.internal.ValidatorMetaData;
import org.eclipse.wst.validation.internal.core.ValidationException;
import org.eclipse.wst.validation.internal.operations.LocalizedMessage;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IProjectValidationContext;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;
import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
import org.eclipse.wst.validation.internal.provisional.core.IValidator;

/**
 * This class is to be used as a base class by clients who want to provide
 * alternate validator implementations for a given validator type.
 * 
 * It locates the currently configured delegate for this validator and calls its
 * validate method.
 * 
 * @see IValidator
 * @see IDelegatingValidator
 * 
 * <p>
 * <b>Note:</b> This class/interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is being made available at this early stage to solicit feedback
 * from pioneering adopters on the understanding that any code that uses this
 * API will almost certainly be broken (repeatedly) as the API evolves.
 * </p>
 */
public class DelegatingValidator implements IDelegatingValidator
{
  /**
   * Default constructor.
   */
  public DelegatingValidator()
  {
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.wst.validation.internal.provisional.core.IValidator#cleanup(org.eclipse.wst.validation.internal.provisional.core.IReporter)
   */
  public void cleanup(IReporter reporter)
  {
    // [Issue] This method does not get passed the validation context. How are
    // going
    // to know what is the delegate in order to invoke its cleanup method?
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.wst.validation.internal.provisional.core.IValidator#validate(org.eclipse.wst.validation.internal.provisional.core.IValidationContext,
   *      org.eclipse.wst.validation.internal.provisional.core.IReporter)
   */
  public void validate(IValidationContext helper, IReporter reporter) throws ValidationException
  {
    // We need to ensure that the context is an IProjectValidationContext. The
    // limitation of using an IValidationContext is that it does not readily
    // provide the project the validator is being invoked upon.

    if (!(helper instanceof IProjectValidationContext))
    {
      // [Issue] Since this message goes to the user, do we need a less
      // technical message text? Maybe we should log instead and send a
      // generic message to the user.
      throw new ValidationException(new LocalizedMessage(IMessage.HIGH_SEVERITY, "The validation context is not an IProjectValidationContext."));
    }

    IProjectValidationContext projectContext = (IProjectValidationContext) helper;
    IProject project = projectContext.getProject();

    ValidatorDelegateDescriptor delegateDescriptor = null;

    try
    {
      ProjectConfiguration projectConfig = ConfigurationManager.getManager().getProjectConfiguration(project);

      if (projectConfig == null)
      {
        throw new ValidationException(new LocalizedMessage(IMessage.HIGH_SEVERITY, "Unable to read the project validation configuration."));
      }

      ValidatorMetaData vmd = ValidationRegistryReader.getReader().getValidatorMetaData(this);

      delegateDescriptor = projectConfig.getDelegateDescriptor(vmd);
    }
    catch (InvocationTargetException e)
    {
      throw new ValidationException(new LocalizedMessage(IMessage.HIGH_SEVERITY, "Error retrieving the project validation configuration."));
    }


    IValidator delegate = delegateDescriptor.getValidator();

    // We need to make it look like this validator is the one generating
    // messages so we wrap the reporter and use this validator as the source.
    // The validation framework does not recognize our validators because they
    // are not registered directly with the framework.
    // We could make them work like the aggregated validators but that would
    // create problems with markers not being cleaned up if someone switches
    // validators.
    // TODO : Maybe we could clear all the markers generated by a delegate when
    // the user chooses a different delegate implementation?

    DelegatingReporter delegatingReporter = new DelegatingReporter(this, reporter);

    delegate.validate(helper, delegatingReporter);
  }

  /**
   * Wraps the original reporter instance to make it look like this validator is
   * the one generating messages. This is needed because the framework ignores
   * messages coming from the delegate validator because it is not registered
   * with the validation framework.
   */
  private class DelegatingReporter implements IReporter
  {
    /**
     * The reporter passed originally to the delegating validator by the
     * framework.
     */
    IReporter delegatingReporter;

    /**
     * The delegating validator.
     */
    IValidator delegatingValidator;

    /**
     * Constructor.
     * 
     * @param validator
     *          the original validator.
     * @param reporter
     *          the reporter originally passed to the delegating validator.
     */
    DelegatingReporter(IValidator validator, IReporter reporter)
    {
      delegatingReporter = reporter;
      delegatingValidator = validator;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#addMessage(org.eclipse.wst.validation.internal.provisional.core.IValidator,
     *      org.eclipse.wst.validation.internal.provisional.core.IMessage)
     */
    public void addMessage(IValidator origin, IMessage message)
    {
      delegatingReporter.addMessage(delegatingValidator, message);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#displaySubtask(org.eclipse.wst.validation.internal.provisional.core.IValidator,
     *      org.eclipse.wst.validation.internal.provisional.core.IMessage)
     */
    public void displaySubtask(IValidator validator, IMessage message)
    {
      delegatingReporter.displaySubtask(delegatingValidator, message);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#getMessages()
     */
    public List getMessages()
    {
      return delegatingReporter.getMessages();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#isCancelled()
     */
    public boolean isCancelled()
    {
      return delegatingReporter.isCancelled();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#removeAllMessages(org.eclipse.wst.validation.internal.provisional.core.IValidator)
     */
    public void removeAllMessages(IValidator origin)
    {
      delegatingReporter.removeAllMessages(delegatingValidator);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#removeAllMessages(org.eclipse.wst.validation.internal.provisional.core.IValidator,
     *      java.lang.Object)
     */
    public void removeAllMessages(IValidator origin, Object object)
    {
      delegatingReporter.removeAllMessages(delegatingValidator, object);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.wst.validation.internal.provisional.core.IReporter#removeMessageSubset(org.eclipse.wst.validation.internal.provisional.core.IValidator,
     *      java.lang.Object, java.lang.String)
     */
    public void removeMessageSubset(IValidator validator, Object obj, String groupName)
    {
      delegatingReporter.removeMessageSubset(delegatingValidator, obj, groupName);
    }
  }
}




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

package org.eclipse.wst.validation.internal.provisional.core;

import org.eclipse.core.resources.IProject;

/**
 * IProjectValidationContext extends IValidationContext to provide access to a
 * reference to the project on which a validator is being invoked.
 * <p>
 * <b>Note:</b> This class/interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is being made available at this early stage to solicit feedback
 * from pioneering adopters on the understanding that any code that uses this
 * API will almost certainly be broken (repeatedly) as the API evolves.
 * </p>
 */
public interface IProjectValidationContext extends IValidationContext
{
  /**
   * Provides the project on which the validator is being invoked.
   * 
   * @return an IProject reference to the project on which the validator is
   *         being invoked.
   */
  IProject getProject();
}




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

package org.eclipse.wst.validation.internal.delegates;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.wst.validation.internal.provisional.core.IValidator;

/**
 * ValidatorDelegateDescriptor stores information about a delegate validator.
 * 
 * It is also used to store the instance of the validator it describes. To
 * obtain the instance call getValidator().
 */
public class ValidatorDelegateDescriptor
{
  /**
   * The instance of the validator refered to by this descriptor.
   */
  private IValidator delegate;

  /**
   * The platform configuration element describing this delegate.
   */
  private IConfigurationElement delegateConfiguration;

  /**
   * The delegating validator's ID.
   */
  private String delegatingValidatorID;

  /**
   * The delegate's ID.
   */
  private String id;

  /**
   * The delegate's display name.
   */
  private String name;

  /**
   * Constructs a descriptor.
   * 
   * @param id
   *          the delegate's uniques id. Must be unique in the context of a
   *          delegating validator.
   * @param delegateConfiguration
   *          the delegates configuration element
   * @param delegateName
   *          the delegate's display name.
   * @param targetValidatorID
   *          the target validator's unique id.
   */
  public ValidatorDelegateDescriptor(String id, IConfigurationElement delegateConfiguration, String delegateName, String targetValidatorID)
  {
    this.id = id;
    this.delegateConfiguration = delegateConfiguration;
    this.name = delegateName;
    this.delegatingValidatorID = targetValidatorID;
  }

  /**
   * Provides the delegate's ID.
   * 
   * @return a string with the fully qualified class name of this validator
   *         implementation.
   */
  public String getId()
  {
    return id;
  }

  /**
   * Provides the delegate's name.
   * 
   * @return a String with the validator's display name.
   */
  public String getName()
  {
    return name;
  }

  /**
   * Retrieves the target validator's ID.
   * 
   * @return a String with the fully qualified class name of the delegating
   *         validator who will delegate its implementation to the validator
   *         described by this descriptor.
   */
  public String getTargetID()
  {
    return delegatingValidatorID;
  }

  /**
   * Provides the instance of the validator delegate pointed to by this
   * descriptor.
   * 
   * @return an IValidator instance.
   */
  public IValidator getValidator()
  {
    if (delegate != null)
    {
      return delegate;
    }

    try
    {
      delegate = (IValidator) delegateConfiguration.createExecutableExtension(ValidatorDelegatesRegistryReader.CLASS_ATTRIBUTE);
    }
    catch (CoreException e)
    {
      e.printStackTrace();
    }

    return delegate;
  }
}




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

package org.eclipse.wst.validation.internal.delegates;

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

import org.eclipse.wst.validation.internal.provisional.core.IValidator;

/**
 * ValidatorDelegatesRegistry is a singleton used to store validator delegate
 * descriptors for each delegating validator.
 */
public class ValidatorDelegatesRegistry
{
  /**
   * The one and only instance of this registry.
   */
  private static ValidatorDelegatesRegistry instance;

  /**
   * Provides the one and only instance of this class.
   * 
   * The actual platform extension registry reading happens at this time.
   * 
   * @see ValidatorDelegatesRegistryReader
   * 
   * @return the validator delegates registry singleton instance.
   */
  public static ValidatorDelegatesRegistry getInstance()
  {
    if (instance == null)
    {
      instance = new ValidatorDelegatesRegistry();

      ValidatorDelegatesRegistryReader reader = new ValidatorDelegatesRegistryReader(instance);
      reader.readRegistry();
    }

    return instance;
  }

  /**
   * The map of target validator id to Map of delegates by id.
   */
  private Map delegatesByTarget = new HashMap();

  /**
   * Adds a descriptor to the registry.
   * 
   * @param descriptor
   *          the descriptor to add. Must not be null.
   */
  void add(ValidatorDelegateDescriptor descriptor)
  {
    if (descriptor == null)
    {
      return;
    }

    String targetID = descriptor.getTargetID();

    Map delegates = (Map) delegatesByTarget.get(targetID);

    if (delegates == null)
    {
      delegates = new HashMap();
      delegatesByTarget.put(targetID, delegates);
    }

    delegates.put(descriptor.getId(), descriptor);
  }

  /**
   * Provides the default delegate ID for the given delegating validator ID.
   * 
   * @param targetID
   *          the delegating validator's ID.
   * @return a String with the ID of the default delegate.
   */
  public String getDefaultDelegate(String targetID)
  {
    Map delegates = getDelegateDescriptors(targetID);

    if (delegates == null)
    {
      return null;
    }

    // TODO: Implement a default attribute and use that to get the default?
    // What happens if two or more delegates claim to be the default one?
    // For now, just pick the first one in the list.

    Iterator delegatesIterator = delegates.values().iterator();

    if (!delegatesIterator.hasNext())
    {
      return null;
    }

    ValidatorDelegateDescriptor descriptor = (ValidatorDelegateDescriptor) delegatesIterator.next();

    return descriptor.getId();
  }

  /**
   * Retrieves a delegate instance based on the target and delegate IDs.
   * 
   * @param targetID
   *          the delegating validator's ID.
   * @param delegateID
   *          the delegate validator's ID.
   * @return an instance of the delegate validator or null if one cannot be
   *         found.
   */
  public IValidator getDelegate(String targetID, String delegateID)
  {
    ValidatorDelegateDescriptor descriptor = getDescriptor(targetID, delegateID);

    if (descriptor == null)
    {
      return null;
    }

    IValidator delegate = descriptor.getValidator();

    return delegate;
  }

  /**
   * Provides a map with all delegates descriptors for the given target, keyed
   * by their ID.
   * 
   * @param targetID
   *          the target (delegating) validator id. Must not be null.
   * @return a Map <string, ValidatorDelegateDescriptor>. May be null if the ID
   *         passed in is not a delegating validator.
   */
  public Map getDelegateDescriptors(String targetID)
  {
    return (Map) delegatesByTarget.get(targetID);
  }

  /**
   * Finds a delegate descriptor based on the target id and delegate id.
   * 
   * @param targetID
   *          the delegating validator's id
   * @param delegateID
   *          the delegate id
   * @return a ValidatorDelegateDescriptor for the given target and id or null
   *         if one cannot be found.
   */
  public ValidatorDelegateDescriptor getDescriptor(String targetID, String delegateID)
  {
    Map delegates = (Map) delegatesByTarget.get(targetID);

    if (delegates == null)
    {
      // No delegates registered for this target.

      return null;
    }

    ValidatorDelegateDescriptor descriptor = (ValidatorDelegateDescriptor) delegates.get(delegateID);

    return descriptor;
  }

  /**
   * Determines if a given validator has delegates.
   * 
   * @param targetID
   *          the target validator id.
   * @return true if the target has registered delegates, false otherwise.
   */
  public boolean hasDelegates(String targetID)
  {
    Map delegatesByID = (Map) delegatesByTarget.get(targetID);

    boolean hasDelegates = (delegatesByID != null);
    return hasDelegates;
  }
}





import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

import org.eclipse.core.resources.IProject;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

import org.eclipse.wst.validation.internal.GlobalConfiguration;
import org.eclipse.wst.validation.internal.ProjectConfiguration;
import org.eclipse.wst.validation.internal.ValidatorMetaData;
import org.eclipse.wst.validation.internal.delegates.IDelegatingValidator;
import org.eclipse.wst.validation.internal.operations.ValidatorManager;
import org.eclipse.wst.validation.internal.provisional.core.IValidator;
import org.eclipse.wst.validation.internal.ui.plugin.ValidationUIPlugin;

/**

	// order to access this field)
	//private boolean _isAutoBuildEnabled; // initialized in the constructor
	private ValidatorMetaData[] _oldVmd = null; // Cache the enabled validators so that, if
  private Map _oldDelegates = null; // Cache the validator delegates.
	// there is no change to this list, the
	// expensive task list update can be avoided
	private boolean _allow = false; // Cache the value of the prefence "allow projects to

			}
		}

    private Image getImage(String imageName) {
      boolean isDisabled = !validatorsTable.isEnabled();
      if (isDisabled) {
          imageName = imageName + "_disabled";  //$NON-NLS-N$
      }
      Image image = ValidationUIPlugin.getPlugin().getImage(imageName);
      return image;
    }
    
		public Image getColumnImage(Object element, int columnIndex) {
			if(columnIndex == 1) {
				if(((ValidatorMetaData)element).isManualValidation())
					return  getImage("ok_tbl");
				return getImage("fail_tbl");
			} 
      else if(columnIndex == 2) {
				if(((ValidatorMetaData)element).isBuildValidation())
					return getImage("ok_tbl");;
				return getImage("fail_tbl");
			}
      else if (columnIndex == 3)
      {
        ValidatorMetaData vmd = (ValidatorMetaData)element;
        IValidator validator = null;
        try
        {
          validator = vmd.getValidator();
        }
        catch (InstantiationException e)
        {
          e.printStackTrace();
        }
        if (validator instanceof IDelegatingValidator)
        {
          return getImage("settings");          
        }
      }
			return null;
		
		}

		// that, if there is no change to this
		// list, the expensive task list
		// update can be avoided

    _oldDelegates =  new HashMap(pagePreferences.getDelegatingValidators());
		
    _allow = pagePreferences.canProjectsOverride();

		page = createPage(parent);
	}

        buildColumn.setText("Build");
        buildColumn.setResizable(false);
        buildColumn.setWidth(30);
        TableColumn settingsColumn = new TableColumn(table, SWT.NONE);
        settingsColumn.setText("Settings");
        settingsColumn.setResizable(false);
        settingsColumn.setWidth(40);
    }
	
	public Composite createPage(Composite parent) throws InvocationTargetException {

				validatorsTable.setEnabled(!disableAllValidation.getSelection());
				enableAllButton.setEnabled(!disableAllValidation.getSelection());
				disableAllButton.setEnabled(!disableAllValidation.getSelection());
        validatorList.refresh();
			}
		});
		

		validatorsTable = new Table(validatorGroup,SWT.BORDER | SWT.FULL_SELECTION);
		TableLayout tableLayout = new TableLayout();
		tableLayout.addColumnData(new ColumnWeightData(160, true));
    tableLayout.addColumnData(new ColumnWeightData(40, true));
    tableLayout.addColumnData(new ColumnWeightData(30, true));
    tableLayout.addColumnData(new ColumnWeightData(40, true));
    
		validatorsTable.setHeaderVisible(true);
		validatorsTable.setLinesVisible(true);
        validatorsTable.setLayout(tableLayout);

    case 2:
      vmd.setBuildValidation(!vmd.isBuildValidation());
      break;
    case 3:
      {
        String delegateID = pagePreferences.getDelegateUniqueName(vmd);
  
        Shell shell = Display.getCurrent().getActiveShell();
        DelegatingValidatorPreferencesDialog dialog = new DelegatingValidatorPreferencesDialog(shell, vmd, delegateID);
  
        dialog.setBlockOnOpen(true);
        dialog.create();
  
        int result = dialog.open();
  
        if (result == Window.OK)
        {
          pagePreferences.setDelegateUniqueName(vmd, dialog.getDelegateID());
        }
      }
      break;
    default:
      break;
    }

			try {
				if (project.isOpen()) {
					ProjectConfiguration prjp = ConfigurationManager.getManager().getProjectConfiguration(project);
					if (!prjp.doesProjectOverride() && (prjp.hasEnabledValidatorsChanged(_oldVmd, allowChanged) || true) && 
              (prjp.haveDelegatesChanged(_oldDelegates, allowChanged) || true)) {
						// If the project used to override the preferences, and the preferences
						// make that impossible now, then update the task list.
						//





import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

import javax.swing.event.HyperlinkEvent;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

import org.eclipse.wst.validation.internal.GlobalConfiguration;
import org.eclipse.wst.validation.internal.ProjectConfiguration;
import org.eclipse.wst.validation.internal.ValidatorMetaData;
import org.eclipse.wst.validation.internal.delegates.IDelegatingValidator;
import org.eclipse.wst.validation.internal.operations.ValidatorManager;
import org.eclipse.wst.validation.internal.provisional.core.IValidator;
import org.eclipse.wst.validation.internal.ui.plugin.ValidationUIPlugin;

/**

		private boolean canOverride = false;

		private ValidatorMetaData[] oldVmd = null; // Cache the enabled validators so that, if there
    private Map oldDelegates = null; // Cache the validator delegates.

		// is no change to this list, the expensive task
		// list update can be avoided

				return null;
			}

      private Image getImage(String imageName) {
        boolean isDisabled = !validatorsTable.isEnabled();
        if (isDisabled) {
            imageName = imageName + "_disabled";  //$NON-NLS-N$
        }
        Image image = ValidationUIPlugin.getPlugin().getImage(imageName);
        return image;
      }
      

      public Image getColumnImage(Object element, int columnIndex) {
				if(columnIndex == 1) {
					if(((ValidatorMetaData)element).isManualValidation())
						return  getImage("ok_tbl");
					return getImage("fail_tbl");
				} else if(columnIndex == 2) {
					if(((ValidatorMetaData)element).isBuildValidation())
						return getImage("ok_tbl");;
					return getImage("fail_tbl");
				}
        else if (columnIndex == 3)
        {
          ValidatorMetaData vmd = (ValidatorMetaData)element;
          IValidator validator = null;
          try
          {
            validator = vmd.getValidator();
          }
          catch (InstantiationException e)
          {
            e.printStackTrace();
          }
          if (validator instanceof IDelegatingValidator)
          {
            return getImage("settings");          
          }
        }
				return null;
			
			}
		}


			//isAutoBuildEnabled = vMgr.isGlobalAutoBuildEnabled();
			//isBuilderConfigured = ValidatorManager.doesProjectSupportBuildValidation(getProject());
			oldVmd = pagePreferences.getEnabledValidators(); // Cache the enabled validators so
      // that, if there is no change to this
      // list, the expensive task list update
      // can be avoided

      oldDelegates =  new HashMap(pagePreferences.getDelegatingValidators());

			createPage(parent);
		}

	        buildColumn.setText("Build");
	        buildColumn.setResizable(false);
	        buildColumn.setWidth(30);
          TableColumn settingsColumn = new TableColumn(table, SWT.NONE);
          settingsColumn.setText("Settings");
          settingsColumn.setResizable(false);
          settingsColumn.setWidth(40);
	    }

		/**

					validatorsTable.setEnabled(!disableAllValidation.getSelection());
					enableAllButton.setEnabled(!disableAllValidation.getSelection());
					disableAllButton.setEnabled(!disableAllValidation.getSelection());
          try {
            updateWidgets();
          } catch (InvocationTargetException exc) {
            displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc);
          }
				}
			});
			

			validatorsTable = new Table(validatorGroup,SWT.BORDER | SWT.FULL_SELECTION);
			TableLayout tableLayout = new TableLayout();
			tableLayout.addColumnData(new ColumnWeightData(160, true));
	    tableLayout.addColumnData(new ColumnWeightData(40, true));
	    tableLayout.addColumnData(new ColumnWeightData(30, true));
      tableLayout.addColumnData(new ColumnWeightData(40, true));
			validatorsTable.setHeaderVisible(true);
			validatorsTable.setLinesVisible(true);
	        validatorsTable.setLayout(tableLayout);

      case 2:
        vmd.setBuildValidation(!vmd.isBuildValidation());
        break;
      case 3:
      {
        String delegateID = pagePreferences.getDelegateUniqueName(vmd);
  
        Shell shell = Display.getCurrent().getActiveShell();
        DelegatingValidatorPreferencesDialog dialog = new DelegatingValidatorPreferencesDialog(shell, vmd, delegateID);
  
        dialog.setBlockOnOpen(true);
        dialog.create();
  
        int result = dialog.open();
  
        if (result == Window.OK)
        {
          pagePreferences.setDelegateUniqueName(vmd, dialog.getDelegateID());
        }
      }
      default:
        break;
      }

		 */
		private void enableDependentControls(boolean overridePreferences) {
			validatorsTable.setEnabled(overridePreferences);
      validatorList.refresh();
			enableAllButton.setEnabled(overridePreferences); // since help messsage isn't
			disableAllButton.setEnabled(overridePreferences);
      
		}

		protected void updateHelp() throws InvocationTargetException {

			// Persist the values.
			storeValues();

			if (pagePreferences.hasEnabledValidatorsChanged(oldVmd, false) ||
          pagePreferences.haveDelegatesChanged(oldDelegates, false)) { 
				// false means that the preference "allow" value hasn't changed
				ValidatorManager.getManager().updateTaskList(getProject()); 
			}

Lines 61-66 Link Here

(-)validateui/org/eclipse/wst/validation/internal/ui/ResourceConstants.java (-1 / +5 lines)
61		61
62	public static final String VBF_UI_POPUP_RUNVALIDATION = "%VBF_UI_POPUP_RUNVALIDATION"; //$NON-NLS-1$	62	public static final String VBF_UI_POPUP_RUNVALIDATION = "%VBF_UI_POPUP_RUNVALIDATION"; //$NON-NLS-1$
63		63
		64	/* package */static final String PREF_BUTTON_ADVANCED = "PREF_BUTTON_ADVANCED"; //$NON-NLS-1$
64	/* package */static final String PREF_BUTTON_ENABLEALL = "PREF_BUTTON_ENABLEALL"; //$NON-NLS-1$	65	/* package */static final String PREF_BUTTON_ENABLEALL = "PREF_BUTTON_ENABLEALL"; //$NON-NLS-1$
65	/* package */static final String PREF_BUTTON_DISABLEALL = "PREF_BUTTON_DISABLEALL"; //$NON-NLS-1$	66	/* package */static final String PREF_BUTTON_DISABLEALL = "PREF_BUTTON_DISABLEALL"; //$NON-NLS-1$
66	/* package */static final String PREF_VALLIST_TITLE = "PREF_VALLIST_TITLE"; //$NON-NLS-1$	67	/* package */static final String PREF_VALLIST_TITLE = "PREF_VALLIST_TITLE"; //$NON-NLS-1$
Lines 89-92 Link Here
89		90
90	/* package */static final String DISABLE_VALIDATION = "DISABLE_VALIDATION"; //$NON-NLS-1$	91	/* package */static final String DISABLE_VALIDATION = "DISABLE_VALIDATION"; //$NON-NLS-1$
91	static final String INFO = "INFO"; //$NON-NLS-1$	92	static final String INFO = "INFO"; //$NON-NLS-1$
92	}	93
		94	String DELEGATES_DIALOG_TITLE = "DELEGATES_DIALOG_TITLE"; //$NON-NLS-1$
		95	String DELEGATES_COMBO_LABEL = "DELEGATES_COMBO_LABEL"; //$NON-NLS-1$
		96	}

Lines 110-115 Link Here

(-)property_files/validate_ui.properties (+3 lines)
110	DISABLE_VALIDATION=Suspend all validators	110	DISABLE_VALIDATION=Suspend all validators
111	INFO=This preference applies to the projects that have org.eclipse.wst.validation.validationbuilder defined.Validators are run on the projects based on the filters defined in the org.eclipse.wst.validation.validator extension point.	111	INFO=This preference applies to the projects that have org.eclipse.wst.validation.validationbuilder defined.Validators are run on the projects based on the filters defined in the org.eclipse.wst.validation.validator extension point.
112		112
		113	DELEGATES_DIALOG_TITLE=Validator Preferences
		114	DELEGATES_COMBO_LABEL=Implementation:
		115
113	#	116	#
114	# End Validation Builder Framework UI Strings	117	# End Validation Builder Framework UI Strings
115	#	118	#




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

package org.eclipse.wst.validation.internal.ui;

import java.util.Collection;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.wst.validation.internal.ValidatorMetaData;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegatesRegistry;

/**
 * Dialog used to allow the user to select a validator delegate from the list of
 * registered delegates for a given delegating validator.
 */
public class DelegatingValidatorPreferencesDialog extends Dialog
{
  /**
   * The delegating validator's descriptor .
   */
  private ValidatorMetaData delegatingValidatorDescriptor;
  /**
   * The selected validator delegate ID.
   */
  private String delegateID;

  /**
   * Constructs the dialog on the given shell.
   * 
   * @param parentShell
   *          the dialog's parent. Must not be null.
   * @param targetID
   *          the delegating validator's id
   * 
   * @param delegateID
   *          the ID of the currently selected validator delegate.
   */
  protected DelegatingValidatorPreferencesDialog(Shell parentShell, ValidatorMetaData vmd, String delegateID)
  {
    super(parentShell);

    delegatingValidatorDescriptor = vmd;
    this.delegateID = delegateID;
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
   */
  protected Control createDialogArea(Composite parent)
  {
    super.createDialogArea(parent);

    getShell().setText(ResourceHandler.getExternalizedMessage(ResourceConstants.DELEGATES_DIALOG_TITLE));

    GridLayout layout = new GridLayout();
    parent.setLayout(layout);

    Label label = new Label(parent, SWT.NONE);
    GridData labelData = new GridData(SWT.FILL, SWT.CENTER, true, false);
    labelData.widthHint = 250;
    label.setLayoutData(labelData);
    label.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.TEXT_FONT));
    String delegatingValidatorName = delegatingValidatorDescriptor.getValidatorDisplayName();
    label.setText(delegatingValidatorName);

    Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL);
    GridData separatorData = new GridData(SWT.FILL, SWT.CENTER, true, false);
    separator.setLayoutData(separatorData);

    Composite group = new Composite(parent, SWT.NONE);
    GridData groupGridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
    group.setLayoutData(groupGridData);
    GridLayout groupLayout = new GridLayout(2, false);
    group.setLayout(groupLayout);

    Label comboLabel = new Label(group, SWT.NONE);
    comboLabel.setLayoutData(new GridData());
    comboLabel.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.DELEGATES_COMBO_LABEL));
    
    Combo combo = new Combo(group, SWT.NONE);
    GridData comboGridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
    combo.setLayoutData(comboGridData);

    final ComboViewer comboViewer = new ComboViewer(combo);
    comboViewer.setContentProvider(new DelegatesContentProvider());
    comboViewer.setLabelProvider(new DelegatesLabelProvider());
    String targetID = delegatingValidatorDescriptor.getValidatorUniqueName();

    comboViewer.addSelectionChangedListener(new ISelectionChangedListener()
    {

      public void selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent event)
      {
        IStructuredSelection selection = (IStructuredSelection) comboViewer.getSelection();
        setDelegateID(((ValidatorDelegateDescriptor) selection.getFirstElement()).getId());
      }
    });

    comboViewer.setInput(targetID);

    ValidatorDelegateDescriptor selected = ValidatorDelegatesRegistry.getInstance().getDescriptor(targetID, delegateID);

    if (selected != null)
    {
      comboViewer.setSelection(new StructuredSelection(new Object[] { selected }));
    }

    Label endSeparator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL);
    GridData endSeparatorData = new GridData(SWT.FILL, SWT.CENTER, true, false); 
    endSeparator.setLayoutData(endSeparatorData);
    
    return parent;
  }

  /**
   * Provides contents for the delegate validators combo box.
   */
  private final class DelegatesContentProvider implements IStructuredContentProvider
  {
    public void dispose()
    {
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
     */
    public Object[] getElements(Object inputElement)
    {
      String targetID = (String) inputElement;
      Collection delegates = ValidatorDelegatesRegistry.getInstance().getDelegateDescriptors(targetID).values();
      return delegates.toArray();
    }

    /*
     * (non-Javadoc)
     * 
     * @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)
    {
    }
  }

  /**
   * Provides the labels/images for the delegate validator combo box
   * 
   * @author vbaciul
   * 
   */
  private final class DelegatesLabelProvider implements ILabelProvider
  {
    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)
     */
    public void addListener(ILabelProviderListener listener)
    {
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()
     */
    public void dispose()
    {
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
     */
    public Image getImage(Object element)
    {
      return null;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
     */
    public String getText(Object element)
    {
      return ((ValidatorDelegateDescriptor) element).getName();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object,
     *      java.lang.String)
     */
    public boolean isLabelProperty(Object element, String property)
    {
      return false;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)
     */
    public void removeListener(ILabelProviderListener listener)
    {
    }
  }

  /*
   * Provides the ID of the currently selected validator delegate ID.
   */
  public String getDelegateID()
  {
    return delegateID;
  }

  /**
   * Sets the currently selected validator delegate ID.
   * 
   * @param delegateID
   */
  private void setDelegateID(String delegateID)
  {
    this.delegateID = delegateID;
  }
}

Return to bug 132228

Lines 11-16 Link Here

(-)validate/org/eclipse/wst/validation/internal/ProjectConfiguration.java (+38 lines)
11	package org.eclipse.wst.validation.internal;	11	package org.eclipse.wst.validation.internal;
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import java.lang.reflect.InvocationTargetException;
		14	import java.util.Map;
14	import java.util.logging.Level;	15	import java.util.logging.Level;
15		16
16	import org.eclipse.core.resources.IMarker;	17	import org.eclipse.core.resources.IMarker;
Lines 19-24 Link Here
19	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.jem.util.logger.LogEntry;	21	import org.eclipse.jem.util.logger.LogEntry;
21	import org.eclipse.jem.util.logger.proxy.Logger;	22	import org.eclipse.jem.util.logger.proxy.Logger;
		23	import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
22	import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;	24	import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;
23		25
24		26
Lines 146-151 Link Here
146	return super.getValidators();	148	return super.getValidators();
147	}	149	}
148		150
		151	/*
		152	* (non-Javadoc)
		153	* @see org.eclipse.wst.validation.internal.ValidationConfiguration#getDelegatingValidators()
		154	*/
		155	public Map getDelegatingValidators() throws InvocationTargetException {
		156	if (useGlobalPreference()) {
		157	return ConfigurationManager.getManager().getGlobalConfiguration().getDelegatingValidators();
		158	}
		159	return super.getDelegatingValidators();
		160	}
		161
149	/**	162	/**
150	* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getEnabledIncrementalValidators(boolean)	163	* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getEnabledIncrementalValidators(boolean)
151	*/	164	*/
Lines 266-271 Link Here
266		279
267	setEnabledManualValidators(gp.getManualEnabledValidators());	280	setEnabledManualValidators(gp.getManualEnabledValidators());
268	setEnabledBuildValidators(gp.getBuildEnabledValidators());	281	setEnabledBuildValidators(gp.getBuildEnabledValidators());
		282	setDelegatingValidators(gp.getDelegatingValidators());
269		283
270	// except for this field, which is unique to the project preferences	284	// except for this field, which is unique to the project preferences
271	setDoesProjectOverride(getDoesProjectOverrideDefault());	285	setDoesProjectOverride(getDoesProjectOverrideDefault());
Lines 276-281 Link Here
276	GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();	290	GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
277	setEnabledManualValidators(gp.getManualEnabledValidators());	291	setEnabledManualValidators(gp.getManualEnabledValidators());
278	setEnabledBuildValidators(gp.getBuildEnabledValidators());	292	setEnabledBuildValidators(gp.getBuildEnabledValidators());
		293	setDelegatingValidators(gp.getDelegatingValidators());
279	}	294	}
280		295
281	/**	296	/**
Lines 464-469 Link Here
464	return false;	479	return false;
465	}	480	}
466		481
		482	public boolean haveDelegatesChanged(Map oldDelegates, boolean allow) throws InvocationTargetException {
		483
		484	if (super.haveDelegatesChanged(oldDelegates)) {
		485	return true;
		486	}
		487
		488	if (allow) {
		489	Map projDelegates = super.getDelegatingValidators();
		490	GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
		491	return gp.haveDelegatesChanged(projDelegates);
		492	}
		493
		494	return false;
		495	}
		496
467		497
468	/**	498	/**
469	* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#deserialize(String)	499	* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#deserialize(String)
Lines 580-583 Link Here
580	}	610	}
581	return super.isDisableAllValidation();	611	return super.isDisableAllValidation();
582	}	612	}
		613
		614	public ValidatorDelegateDescriptor getDelegateDescriptor(ValidatorMetaData vmd) throws InvocationTargetException {
		615	if (useGlobalPreference()) {
		616	return ConfigurationManager.getManager().getGlobalConfiguration().getDelegateDescriptor(vmd);
		617	}
		618
		619	return super.getDelegateDescriptor(vmd);
		620	}
583	}	621	}

Lines 38-44 Link Here

(-)validate/org/eclipse/wst/validation/internal/ConfigurationConstants.java (-1 / +3 lines)
38	public static final int DEPTH_INFINITE = IResource.DEPTH_INFINITE;	38	public static final int DEPTH_INFINITE = IResource.DEPTH_INFINITE;
39	public static final int DEPTH_ZERO = IResource.DEPTH_ZERO;	39	public static final int DEPTH_ZERO = IResource.DEPTH_ZERO;
40	/* package */static final String ELEMENT_SEPARATOR = ";"; //$NON-NLS-1$ // separates the name of one IValidator from the next in the list of enabled validators for a project or preference	40	/* package */static final String ELEMENT_SEPARATOR = ";"; //$NON-NLS-1$ // separates the name of one IValidator from the next in the list of enabled validators for a project or preference
41		41	static final String DELEGATES_SEPARATOR = "="; //$NON-NLS-1$ // Separates the delegating validator id from the delegate validator id in the list of delegates
42	// The following values must match the attributes in the preference marker as shown in	42	// The following values must match the attributes in the preference marker as shown in
43	// plugin.xml	43	// plugin.xml
44	// Even though the plugin.xml values are not used to create new Preference or Project markers,	44	// Even though the plugin.xml values are not used to create new Preference or Project markers,
Lines 46-51 Link Here
46	// These are the QualifiedNames used to persist the user's settings.	46	// These are the QualifiedNames used to persist the user's settings.
47	/* package */static final String ENABLED_MANUAL_VALIDATORS = "enabledManualValidatorList"; //$NON-NLS-1$ // String	47	/* package */static final String ENABLED_MANUAL_VALIDATORS = "enabledManualValidatorList"; //$NON-NLS-1$ // String
48	/* package */static final String ENABLED_BUILD_VALIDATORS = "enabledBuildValidatorList"; //$NON-NLS-1$ // String	48	/* package */static final String ENABLED_BUILD_VALIDATORS = "enabledBuildValidatorList"; //$NON-NLS-1$ // String
		49	/* package */static final String DELEGATE_VALIDATORS = "delegateValidatorList"; //$NON-NLS-1$ // String
49	public static final String J2EE_PLUGIN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$ // For 4.03, this is the plugin id that the validation constants were declared in.	50	public static final String J2EE_PLUGIN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$ // For 4.03, this is the plugin id that the validation constants were declared in.
50	/* package */static final String MAXNUMMESSAGES = "maxNumMessages"; //$NON-NLS-1$ // integer	51	/* package */static final String MAXNUMMESSAGES = "maxNumMessages"; //$NON-NLS-1$ // integer
51	public static final String PLUGIN_ID = ValidationPlugin.PLUGIN_ID;	52	public static final String PLUGIN_ID = ValidationPlugin.PLUGIN_ID;
Lines 61-66 Link Here
61	/* package */static final QualifiedName USER_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource	62	/* package */static final QualifiedName USER_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
62	/* package */static final QualifiedName USER_MANUAL_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationManualConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource	63	/* package */static final QualifiedName USER_MANUAL_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationManualConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
63	/* package */static final QualifiedName USER_BUILD_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationBuildConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource	64	/* package */static final QualifiedName USER_BUILD_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationBuildConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
		65	/* package */static final QualifiedName DELEGATES_PREFERENCE = new QualifiedName(PLUGIN_ID, "ValidationDelegatesConfiguration"); //$NON-NLS-1$ // ValidationConfiguration for the IResource
64		66
65	// Validation message marker constants	67	// Validation message marker constants
66	/* package */static final String VALIDATION_MARKER = PLUGIN_ID + ".problemmarker"; //$NON-NLS-1$ // The extension which is used to add validation markers to the task list	68	/* package */static final String VALIDATION_MARKER = PLUGIN_ID + ".problemmarker"; //$NON-NLS-1$ // The extension which is used to add validation markers to the task list

Added Link Here

(-)xsds/validatorDelegates.exsd (+134 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.wst.validation">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.wst.validation" id="validatorDelegates" name="Validator Delegates"/>
7	</appInfo>
8	<documentation>
9	This extension point allows validator providers to contribute alternate implementations for a delegating validator.
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<complexType>
15	<sequence>
16	<element ref="delegate"/>
17	</sequence>
18	<attribute name="point" type="string" use="required">
19	<annotation>
20	<documentation>
21
22	</documentation>
23	</annotation>
24	</attribute>
25	<attribute name="id" type="string">
26	<annotation>
27	<documentation>
28
29	</documentation>
30	</annotation>
31	</attribute>
32	<attribute name="name" type="string">
33	<annotation>
34	<documentation>
35
36	</documentation>
37	<appInfo>
38	<meta.attribute translatable="true"/>
39	</appInfo>
40	</annotation>
41	</attribute>
42	</complexType>
43	</element>
44
45	<element name="delegate">
46	<annotation>
47	<documentation>
48	Defines a validator delegate. Delegating validators can have one or more delegates registered, only one of which can be active (selected) at once.
49	</documentation>
50	</annotation>
51	<complexType>
52	<attribute name="class" type="string" use="required">
53	<annotation>
54	<documentation>
55	Specifies the class name of the delegate validator. The class must implement IValidator.
56	</documentation>
57	<appInfo>
58	<meta.attribute kind="java" basedOn="org.eclipse.wst.validation.internal.provisional.core.IValidator"/>
59	</appInfo>
60	</annotation>
61	</attribute>
62	<attribute name="target" type="string" use="required">
63	<annotation>
64	<documentation>
65	Specifies the id of the validator extension for which this delegate is being registered.
66	</documentation>
67	</annotation>
68	</attribute>
69	<attribute name="name" type="string" use="required">
70	<annotation>
71	<documentation>
72
73	</documentation>
74	</annotation>
75	</attribute>
76	</complexType>
77	</element>
78
79	<annotation>
80	<appInfo>
81	<meta.section type="since"/>
82	</appInfo>
83	<documentation>
84	<b>This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.</b>
85	</documentation>
86	</annotation>
87
88	<annotation>
89	<appInfo>
90	<meta.section type="examples"/>
91	</appInfo>
92	<documentation>
93	<extension point="org.eclipse.wst.validation.validatorDelegates">
94	<delegate
95	class="com.acme.fast.SuperFastValidator"
96	name="Super fast validator"
97	target="org.acme.core.ACMEDelegatingValidator"/>
98	</extension>
99	</documentation>
100	</annotation>
101
102	<annotation>
103	<appInfo>
104	<meta.section type="apiInfo"/>
105	</appInfo>
106	<documentation>
107	A delegate validator will have to implement the IValidator interface.
108	The target validator, the one who will delegate its implementation to a delegate validator will have to extend org.eclipse.wst.validation.delegates.BaseDelegatingValidator.
109	</documentation>
110	</annotation>
111
112	<annotation>
113	<appInfo>
114	<meta.section type="implementation"/>
115	</appInfo>
116	<documentation>
117
118	</documentation>
119	</annotation>
120
121	<annotation>
122	<appInfo>
123	<meta.section type="copyright"/>
124	</appInfo>
125	<documentation>
126	Copyright (c) 2006 IBM Corporation and others.<br>
127	All rights reserved. This program and the accompanying materials are made
128	available under the terms of the Eclipse Public License v1.0 which accompanies
129	this distribution, and is available at <a
130	href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
131	</documentation>
132	</annotation>
133
134	</schema>

Added Link Here

(-)validate/org/eclipse/wst/validation/internal/delegates/IDelegatingValidator.java (+34 lines)
1	/*******************************************************************************
2	* Copyright (c) 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
12	package org.eclipse.wst.validation.internal.delegates;
13
14	import org.eclipse.wst.validation.internal.provisional.core.IValidator;
15
16	/**
17	* A delegating validator delegates the actual validation work to a delegate
18	* validator. This is a marker interface used internally by the framework to
19	* determine if a delegate is a delegating validator.
20	*
21	* [Issue] Could/should this interface be replaced with an attribute on the
22	* validators extension definition?
23	*
24	* <p>
25	* <b>Note:</b> This class/interface is part of an interim API that is still
26	* under development and expected to change significantly before reaching
27	* stability. It is being made available at this early stage to solicit feedback
28	* from pioneering adopters on the understanding that any code that uses this
29	* API will almost certainly be broken (repeatedly) as the API evolves.
30	* </p>
31	*/
32	public interface IDelegatingValidator extends IValidator
33	{
34	}

Added Link Here

(-)validate_core/org/eclipse/wst/validation/internal/provisional/core/IProjectValidationContext.java (+36 lines)
1	/*******************************************************************************
2	* Copyright (c) 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
12	package org.eclipse.wst.validation.internal.provisional.core;
13
14	import org.eclipse.core.resources.IProject;
15
16	/**
17	* IProjectValidationContext extends IValidationContext to provide access to a
18	* reference to the project on which a validator is being invoked.
19	* <p>
20	* <b>Note:</b> This class/interface is part of an interim API that is still
21	* under development and expected to change significantly before reaching
22	* stability. It is being made available at this early stage to solicit feedback
23	* from pioneering adopters on the understanding that any code that uses this
24	* API will almost certainly be broken (repeatedly) as the API evolves.
25	* </p>
26	*/
27	public interface IProjectValidationContext extends IValidationContext
28	{
29	/**
30	* Provides the project on which the validator is being invoked.
31	*
32	* @return an IProject reference to the project on which the validator is
33	* being invoked.
34	*/
35	IProject getProject();
36	}