Attachment #137063 for bug #267343




import org.eclipse.jpt.db.ConnectionAdapter;
import org.eclipse.jpt.db.ConnectionListener;
import org.eclipse.jpt.db.ConnectionProfile;
import org.eclipse.jpt.db.ConnectionProfileFactory;
import org.eclipse.jpt.db.ConnectionProfileListener;
import org.eclipse.jpt.db.Database;
import org.eclipse.jpt.db.JptDbPlugin;
import org.eclipse.jpt.db.Schema;
import org.eclipse.jpt.db.SchemaContainer;
import org.eclipse.jpt.db.ui.internal.DTPUiTools;
import org.eclipse.jpt.ui.internal.JpaHelpContextIds;
import org.eclipse.jpt.ui.internal.JptUiMessages;

{
	public static final String PROP_ID = "org.eclipse.jpt.ui.jpaProjectPropertiesPage"; //$NON-NLS-1$

	WritablePropertyValueModel<IProject> projectHolder;
	
	PropertyValueModel<JpaProject> jpaProjectHolder;
	
	Trigger trigger;
	
	PropertyChangeListener validationListener;
	
	PropertyChangeListener overrideDefaultCatalogListener;
	
	PropertyChangeListener overrideDefaultSchemaListener;

	PropertyChangeListener platformChangelistener;
	
	BufferedWritablePropertyValueModel<String> platformIdModel;
	
	BufferedWritablePropertyValueModel<String> connectionModel;
	
	ListValueModel<String> connectionChoicesModel;
	
	PropertyValueModel<ConnectionProfile> connectionProfileModel;
	
	PropertyValueModel<Boolean> databaseSupportsCatalogsModel;
	
	PropertyValueModel<Boolean> databaseExistsModel;
	
	BufferedWritablePropertyValueModel<Boolean> overrideDefaultCatalogModel;
	
	BufferedWritablePropertyValueModel<String> defaultCatalogModel;
	
	WritablePropertyValueModel<String> combinedDefaultCatalogModel;
	
	ListValueModel<String> catalogChoicesModel;

	BufferedWritablePropertyValueModel<Boolean> overrideDefaultSchemaModel;
	
	BufferedWritablePropertyValueModel<String> defaultSchemaModel;
	
	WritablePropertyValueModel<String> combinedDefaultSchemaModel;
	
	ListValueModel<String> schemaChoicesModel;
	
	BufferedWritablePropertyValueModel<Boolean> discoverAnnotatedClassesModel;
	
	WritablePropertyValueModel<Boolean> listAnnotatedClassesModel;


	// ************ construction/initialization ************

		this.connectionChoicesModel = this.initializeConnectionChoicesModel();
		this.connectionProfileModel = this.initializeConnectionProfileModel();
		
		this.databaseSupportsCatalogsModel = this.initializeDatabaseSupportsCatalogsModel();
		this.databaseExistsModel = this.initializeDatabaseExistsModel();
		
		this.overrideDefaultCatalogModel = this.initializeOverrideDefaultCatalogModel();
		this.defaultCatalogModel = this.initializeDefaultCatalogModel();
		this.combinedDefaultCatalogModel = this.initializeCombinedDefaultCatalogModel();

	}
	
	protected ListValueModel<String> initializeConnectionChoicesModel() {
		return new ExtendedListValueModelWrapper<String>(
				new SortedListValueModelAdapter<String>(	
					new CollectionListValueModelAdapter<String>(
					new CollectionListValueModelAdapter(
						new ConnectionChoicesModel(this.projectHolder))));
	}
	

			}
		};
	}
	
	protected PropertyValueModel<Boolean> initializeDatabaseSupportsCatalogsModel() {
		return new DatabaseSupportsCatalogsModel(this.connectionProfileModel);
	}

	protected PropertyValueModel<Boolean> initializeDatabaseExistsModel() {
		return new DatabaseExistsModel(this.connectionProfileModel);
	}

	protected BufferedWritablePropertyValueModel<Boolean> initializeOverrideDefaultCatalogModel() {
		OverrideDefaultCatalogModel model = new OverrideDefaultCatalogModel(this.jpaProjectHolder);
		BufferedWritablePropertyValueModel<Boolean> modelBuffer = 
			new BufferedWritablePropertyValueModel(model, this.trigger);
		model.addPropertyChangeListener(PropertyValueModel.VALUE, this.overrideDefaultCatalogListener);

		BufferedWritablePropertyValueModel<Boolean> bufferedModel = new BufferedWritablePropertyValueModel<Boolean>(model, this.trigger);
		bufferedModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.validationListener);

		return bufferedModel;
	}
	
	protected BufferedWritablePropertyValueModel<String> initializeDefaultCatalogModel() {

	}
	
	protected ListValueModel<String> initializeCatalogChoicesModel() {
		Collection<CollectionValueModel<String>> cvms = new ArrayList<CollectionValueModel<String>>();
		cvms.add(new PropertyCollectionValueModelAdapter<String>(this.defaultCatalogModel));
		cvms.add(new CatalogChoicesModel(this.connectionProfileModel));
		return new SortedListValueModelAdapter<String>(
			new CompositeCollectionValueModel<CollectionValueModel<String>, String>(cvms) {
				@Override
				public Iterator<String> iterator() {
					Set<String> uniqueValues = new HashSet<String>();
					CollectionTools.addAll(uniqueValues, super.iterator());
						if (each != null) {
							uniqueValues.add(each);
						}
					}
					return uniqueValues.iterator();
				}
			});

			new CombinedDefaultSchemaModel(
				this.defaultSchemaModel,
				this.overrideDefaultSchemaModel,
				new DefaultDefaultSchemaModel(this.defaultCatalogModel, this.connectionProfileModel));
		model.addPropertyChangeListener(PropertyValueModel.VALUE, this.validationListener);
		return model;
	}
	
	protected ListValueModel<String> initializeSchemaChoicesModel() {
		Collection<CollectionValueModel<String>> cvms = new ArrayList<CollectionValueModel<String>>();
		cvms.add(new PropertyCollectionValueModelAdapter<String>(this.defaultSchemaModel));
		cvms.add(new SchemaChoicesModel(this.defaultCatalogModel, this.connectionProfileModel));
		return new SortedListValueModelAdapter<String>(
			new CompositeCollectionValueModel<CollectionValueModel<String>, String>(cvms) {
				@Override
				public Iterator<String> iterator() {
					Set<String> uniqueValues = new HashSet<String>();
					CollectionTools.addAll(uniqueValues, super.iterator());
						if (each != null) {
							uniqueValues.add(each);
						}
					}
					return uniqueValues.iterator();
				}
			});

		protected V value;
		
		
		BasePropertyAspectAdapter(PropertyValueModel<S> subjectHolder) {
			super(subjectHolder);
			this.value = null;
		}

		
		public final void setValue(V value) {
			if (this.subject != null) {
				this.setValue_(value);
			}
		}
		
		protected void setValue_(@SuppressWarnings("unused") V v) {
			throw new UnsupportedOperationException();
		}
		
		

		// ************ internal ***********************************************
		
		protected V buildValue() {
			return (this.subject == null) ? null : this.buildValue_();
				return buildValue_();
			}
			return null;
		}
		
		protected abstract V buildValue_();
		
		protected void valueChanged() {
			V old = this.getValue();  // subclasses override #getValue()...
			this.value = this.buildValue();
			this.fireAspectChange(old, this.getValue());
		}
	}
	

		extends AspectAdapter<S>
		implements CollectionValueModel<E>
	{
		BaseCollectionAspectAdapter(PropertyValueModel<? extends S> subjectHolder) {
			super(subjectHolder);
		}
		

		private IPreferenceChangeListener platformChangeListener;
		
		
		JpaProjectHolder(PropertyValueModel<IProject> projectHolder) {
			super(projectHolder);
			this.platformChangeListener = buildPlatformChangeListener();
		}

		
		@Override
		protected void engageSubject_() {
			IEclipsePreferences preferences = JptCorePlugin.getProjectPreferences(this.subject);
			preferences.addPreferenceChangeListener(this.platformChangeListener);
			super.engageSubject_();
			this.getPreferences().addPreferenceChangeListener(this.platformChangeListener);
		}
		
		@Override
		protected void disengageSubject_() {
			this.getPreferences().removePreferenceChangeListener(this.platformChangeListener);
			preferences.removePreferenceChangeListener(this.platformChangeListener);
			super.disengageSubject_();
		}

		protected IEclipsePreferences getPreferences() {
			return JptCorePlugin.getProjectPreferences(this.subject);
		}
		
		// ************ internal ***********************************************
		

	private static class PlatformIdModel
		extends BasePropertyAspectAdapter<JpaProject, String>
	{
		PlatformIdModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
			super(jpaProjectHolder);
		}
		

	
	private final class PlatformGroup
	{
		PlatformGroup(Composite composite) {
			Group group = new Group(composite, SWT.NONE);
			group.setText(JptUiMessages.JpaFacetWizardPage_platformLabel);
			group.setLayout(new GridLayout());

		private PropertyChangeListener connectionChangeListener;
		
		
		ConnectionModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
			super(jpaProjectHolder);
			this.connectionChangeListener = buildConnectionChangeListener();
		}

		
		@Override
		protected void engageSubject_() {
			JpaDataSource dataSource = this.subject.getDataSource();
			dataSource.addPropertyChangeListener(JpaDataSource.CONNECTION_PROFILE_NAME_PROPERTY, this.connectionChangeListener);
			super.engageSubject_();
			this.subject.getDataSource().addPropertyChangeListener(JpaDataSource.CONNECTION_PROFILE_NAME_PROPERTY, this.connectionChangeListener);
		}
		
		@Override
		protected void disengageSubject_() {
			this.subject.getDataSource().removePropertyChangeListener(JpaDataSource.CONNECTION_PROFILE_NAME_PROPERTY, this.connectionChangeListener);
			dataSource.removePropertyChangeListener(JpaDataSource.CONNECTION_PROFILE_NAME_PROPERTY, this.connectionChangeListener);
			super.disengageSubject_();
		}
		

		private ConnectionProfileListener connectionProfileListener;
		
		
		ConnectionChoicesModel(PropertyValueModel<IProject> subjectHolder) {
			super(subjectHolder);
			this.connectionProfileListener = buildConnectionProfileListener();
		}

		
		@Override
		protected void engageSubject_() {
			this.getConnectionProfileFactory().addConnectionProfileListener(this.connectionProfileListener);
				addConnectionProfileListener(this.connectionProfileListener);
		}
		
		@Override
		protected void disengageSubject_() {
			this.getConnectionProfileFactory().removeConnectionProfileListener(this.connectionProfileListener);
				removeConnectionProfileListener(this.connectionProfileListener);
		}
		
		

		
		@Override
		protected Iterator<String> iterator_() {
			return this.getConnectionProfileFactory().connectionProfileNames();
		}

		private ConnectionProfileFactory getConnectionProfileFactory() {
			return JptDbPlugin.instance().getConnectionProfileFactory();
		}
	}
	

	private abstract static class OverrideDefaultModel
		extends BasePropertyAspectAdapter<JpaProject, Boolean>
	extends BasePropertyAspectAdapter<JpaProject, Boolean>
	{
		// the superclass "value" is the *cached* value
		private Boolean actualValue;


		OverrideDefaultModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
			super(jpaProjectHolder);
		}
		

		
		@Override
		public Boolean getValue() {
			Boolean v = super.getValue();
			return (v == null) ? Boolean.FALSE : v;
		}
		
		@Override
		public void setValue_(Boolean newValue) {
			this.actualValue = newValue;
			this.valueChanged();
		}
		
		

		
		@Override
		protected void engageSubject_() {
			// we need to build 'actualValue' *before* calling 'super'
			// because 'super' calls back here to #buildValue_()
			this.actualValue = this.buildActualValue_();
			super.engageSubject_();
		}
		
		@Override
		protected void disengageSubject_() {
			this.actualValue = null;
			super.disengageSubject_();
			this.actualValue = null;
		}
		
		

		}
		
		protected Boolean buildActualValue_() {
			return Boolean.valueOf(this.subjectHasUserOverrideDefault());
		}

		protected boolean subjectHasUserOverrideDefault() {
			return ! StringTools.stringIsEmpty(this.getSubjectUserOverrideDefault());
		}
		
		protected abstract String getSubjectUserOverrideDefault();
	}

	
	// ************ Catalog ************
	private static class OverrideDefaultCatalogModel
		extends OverrideDefaultModel
	{
		OverrideDefaultCatalogModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
			super(jpaProjectHolder);
		}

		@Override
		protected String getSubjectUserOverrideDefault() {
			return this.subject.getUserOverrideDefaultCatalog();
		}
	}


	private static class DefaultCatalogModel
		extends PropertyAspectAdapter<JpaProject, String>
	{
		DefaultCatalogModel(PropertyValueModel<JpaProject> jpaProjectModel) { 
			super(jpaProjectModel, JpaProject.USER_OVERRIDE_DEFAULT_CATALOG_PROPERTY);
		}
		

			return this.subject.getUserOverrideDefaultCatalog();
		}
	}

	private abstract static class ConnectionProfilePropertyAspectAdapter<V>
		extends BasePropertyAspectAdapter<ConnectionProfile, V>
	{
		private ConnectionListener connectionListener;

		ConnectionProfilePropertyAspectAdapter(PropertyValueModel<ConnectionProfile> connectionProfileModel) {
		private DefaultDefaultCatalogModel(
				PropertyValueModel<ConnectionProfile> connectionProfileModel) {
			super(connectionProfileModel);
			this.connectionListener = this.buildConnectionListener();
		}

		// the connection opening is probably the only thing that will happen...
		// ************ initialization *****************************************
		
		private ConnectionListener buildConnectionListener() {
			return new ConnectionAdapter() {
				@Override
				public void opened(ConnectionProfile profile) {
					ConnectionProfilePropertyAspectAdapter.this.profileOpened(profile);
						valueChanged();
					}
				}
				@Override
				public void catalogChanged(ConnectionProfile profile, Catalog catalog) {
					if (profile.equals(DefaultDefaultCatalogModel.this.subject)) {
						valueChanged();
					}
				}
			};
		}

		void profileOpened(ConnectionProfile profile) {
			if (profile.equals(this.subject)) {
				this.valueChanged();
			}
		}

		@Override
		protected void engageSubject_() {
			this.subject.addConnectionListener(this.connectionListener);
			super.engageSubject_();
			this.subject.addConnectionListener(this.connectionListener);
		}

		@Override
		protected void disengageSubject_() {
			this.subject.removeConnectionListener(this.connectionListener);
			super.disengageSubject_();
		}

	}

	private static class DatabaseSupportsCatalogsModel
		extends ConnectionProfilePropertyAspectAdapter<Boolean>
	{
		DatabaseSupportsCatalogsModel(PropertyValueModel<ConnectionProfile> connectionProfileModel) {
			super(connectionProfileModel);
		}

		@Override
		protected Boolean buildValue_() {
			return Boolean.valueOf(this.databaseSupportsCatalogs());
		}

		private boolean databaseSupportsCatalogs() {
			Database db = this.subject.getDatabase();
			return (db != null) && db.supportsCatalogs();
		}
	}

	private static class DatabaseExistsModel
		extends ConnectionProfilePropertyAspectAdapter<Boolean>
	{
		DatabaseExistsModel(PropertyValueModel<ConnectionProfile> connectionProfileModel) {
			super(connectionProfileModel);
		}

		@Override
		protected Boolean buildValue_() {
			return Boolean.valueOf(this.databaseExists());
		}

		private boolean databaseExists() {
			return (this.subject.getDatabase() != null);
		}
	}

	private static class DefaultDefaultCatalogModel
		extends ConnectionProfilePropertyAspectAdapter<String>
	{
		DefaultDefaultCatalogModel(PropertyValueModel<ConnectionProfile> connectionProfileModel) {
			super(connectionProfileModel);
		}

		@Override
		protected String buildValue_() {
			Database db = this.subject.getDatabase();

		private PropertyValueModel<String> defaultDefaultCatalogModel;
		
		
		CombinedDefaultCatalogModel(
				WritablePropertyValueModel<String> defaultCatalogModel,
				PropertyValueModel<Boolean> overrideDefaultCatalogModel,
				PropertyValueModel<String> defaultDefaultCatalogModel) {
			super(
				new CompositeListValueModel<ListValueModel<?>,Object>(
					CollectionTools.<ListValueModel<?>>list(
						new PropertyListValueModelAdapter<String>(defaultCatalogModel),
						new PropertyListValueModelAdapter<Boolean>(overrideDefaultCatalogModel),
						new PropertyListValueModelAdapter<String>(defaultDefaultCatalogModel)

			if (this.overrideDefaultCatalogModel.getValue()) {
				return this.defaultCatalogModel.getValue();
			}
			return this.defaultDefaultCatalogModel.getValue();
				return this.defaultDefaultCatalogModel.getValue();
			}
		}
		
		

	}

	
	private static class ConnectionProfileCollectionAspectAdapter<E>
		extends BaseCollectionAspectAdapter<ConnectionProfile, E>
	{
		private ConnectionListener connectionListener;

		ConnectionProfileCollectionAspectAdapter(PropertyValueModel<ConnectionProfile> subjectHolder) {
		private CatalogChoicesModel(PropertyValueModel<ConnectionProfile> subjectHolder) {
			super(subjectHolder);
			this.connectionListener = this.buildConnectionListener();
		}

		// the connection opening is probably the only thing that will happen...
		// ************ initialization *****************************************
		
		private ConnectionListener buildConnectionListener() {
			return new ConnectionAdapter() {
				@Override
				public void opened(ConnectionProfile profile) {
					ConnectionProfileCollectionAspectAdapter.this.profileOpened(profile);
						collectionChanged();
					}
				}
				@Override
				public void catalogChanged(ConnectionProfile profile, Catalog catalog) {
					if (profile.equals(CatalogChoicesModel.this.subject)) {
						collectionChanged();
					}
				}
			};
		}

		void profileOpened(ConnectionProfile profile) {
			if (profile.equals(this.subject)) {
				this.collectionChanged();
			}
		}

		@Override
		protected void engageSubject_() {
			this.subject.addConnectionListener(this.connectionListener);
		}

		@Override
		protected void disengageSubject_() {
			this.subject.removeConnectionListener(this.connectionListener);
		}

	}

	private static class CatalogChoicesModel
		extends ConnectionProfileCollectionAspectAdapter<String>
	{
		CatalogChoicesModel(PropertyValueModel<ConnectionProfile> subjectHolder) {
			super(subjectHolder);
		}

		@Override
		protected Iterator<String> iterator_() {
			Database db = this.subject.getDatabase();
			return ((db == null) || ( ! db.supportsCatalogs())) ? 
				EmptyIterator.<String>instance() : 
				db.sortedCatalogIdentifiers();
		}
	}

	
	// ************ Schema ************
	private static class OverrideDefaultSchemaModel
		extends OverrideDefaultModel
	{
		OverrideDefaultSchemaModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
		private Boolean actualValue;
		
		
		private OverrideDefaultSchemaModel(PropertyValueModel<JpaProject> jpaProjectHolder) {
			super(jpaProjectHolder);
		}

		
		// ************ WritablePropertyValueModel impl ************************
		
		@Override
		public Boolean getValue() {
			Boolean value = super.getValue();
			return (value == null) ? Boolean.FALSE : value;
		}
		
		@Override
		public void setValue_(Boolean newValue) {
			this.actualValue = newValue;
			valueChanged();
		}
		
		
		// ************ AspectAdapter impl *************************************
		
		@Override
		protected void engageSubject_() {
			this.actualValue = this.buildActualValue_();
			super.engageSubject_();
		}
		
		@Override
		protected void disengageSubject_() {
			this.actualValue = null;
			super.disengageSubject_();
		}
		
		
		// ************ internal ***********************************************
		
		@Override
		public String getSubjectUserOverrideDefault() {
			return this.subject.getUserOverrideDefaultSchema();
		}
		
		protected Boolean buildActualValue_() {
			return ! StringTools.stringIsEmpty(this.subject.getUserOverrideDefaultSchema());
		}
	}
	

	private static class DefaultSchemaModel
		extends PropertyAspectAdapter<JpaProject, String>
	{
		DefaultSchemaModel(PropertyValueModel<JpaProject> jpaProjectModel) { 
			super(jpaProjectModel, JpaProject.USER_OVERRIDE_DEFAULT_SCHEMA_PROPERTY);
		}
		

	
	
	private static class DefaultDefaultSchemaModel
		extends ConnectionProfilePropertyAspectAdapter<String>
	{
		private final PropertyValueModel<String> defaultCatalogModel;
		private final PropertyChangeListener catalogListener;

		DefaultDefaultSchemaModel(PropertyValueModel<String> defaultCatalogModel,
				PropertyValueModel<ConnectionProfile> connectionProfileModel) {
			super(connectionProfileModel);
			this.defaultCatalogModel = defaultCatalogModel;
			this.catalogListener = this.buildCatalogListener();
		}

		private PropertyChangeListener buildCatalogListener() {
			return new PropertyChangeListener() {
				public void propertyChanged(PropertyChangeEvent event) {
					DefaultDefaultSchemaModel.this.valueChanged();
			return new ConnectionAdapter() {
				@Override
				public void opened(ConnectionProfile profile) {
					if (profile.equals(DefaultDefaultSchemaModel.this.subject)) {
						valueChanged();
					}
				}
				@Override
				public void schemaChanged(ConnectionProfile profile, Schema schema) {
					if (profile.equals(DefaultDefaultSchemaModel.this.subject)) {
						valueChanged();
					}
				}
			};
		}

		
		// ************ AspectAdapter impl *************************************
		
		@Override
		protected void engageSubject_() {
			// call 'super' last?
			this.defaultCatalogModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.catalogListener);
			super.engageSubject_();
		}
		
		@Override
		protected void disengageSubject_() {
			this.subject.removeConnectionListener(this.connectionListener);
			super.disengageSubject_();
			this.defaultCatalogModel.removePropertyChangeListener(PropertyValueModel.VALUE, this.catalogListener);
		}

		
		// ************ internal ***********************************************
		
		@Override
		protected String buildValue_() {
			Schema schema = this.getDefaultSchema();
			if (db == null) {
				return null;
			}
			Schema schema = db.getDefaultSchema();
			return (schema == null) ? null : schema.getIdentifier();
		}

		private Schema getDefaultSchema() {
			SchemaContainer sc = this.getSchemaContainer();
			return (sc == null) ? null : sc.getDefaultSchema();
		}

		private SchemaContainer getSchemaContainer() {
			return this.databaseSupportsCatalogs() ? this.getCatalog() : this.getDatabase();
		}

		private boolean databaseSupportsCatalogs() {
			Database db = this.getDatabase();
			return (db != null) && db.supportsCatalogs();
		}

		private Catalog getCatalog() {
			String name = this.defaultCatalogModel.getValue();
			return (name == null) ? null : this.getCatalog(name);
		}

		/**
		 * pre-condition: 'name' is not null
		 */
		private Catalog getCatalog(String name) {
			Database db = this.getDatabase();
			return (db == null) ? null : db.getCatalogForIdentifier(name);
		}

		private Database getDatabase() {
			return this.subject.getDatabase();
		}

	}
	
	

		private PropertyValueModel<String> defaultDefaultSchemaModel;
		
		
		CombinedDefaultSchemaModel(
				WritablePropertyValueModel<String> defaultSchemaModel,
				PropertyValueModel<Boolean> overrideDefaultSchemaModel,
				PropertyValueModel<String> defaultDefaultSchemaModel) {

			if (this.overrideDefaultSchemaModel.getValue()) {
				return this.defaultSchemaModel.getValue();
			}
			return this.defaultDefaultSchemaModel.getValue();
				return this.defaultDefaultSchemaModel.getValue();
			}
		}
		
		



	private static class SchemaChoicesModel
		extends ConnectionProfileCollectionAspectAdapter<String>
	{
		private final PropertyValueModel<String> defaultCatalogModel;
		private final PropertyChangeListener catalogListener;

		SchemaChoicesModel(PropertyValueModel<String> defaultCatalogModel,
				PropertyValueModel<ConnectionProfile> subjectHolder) {
			super(subjectHolder);
			this.defaultCatalogModel = defaultCatalogModel;
			this.catalogListener = this.buildCatalogListener();
		}

		private PropertyChangeListener buildCatalogListener() {
			return new PropertyChangeListener() {
				public void propertyChanged(PropertyChangeEvent event) {
					collectionChanged();
			return new ConnectionAdapter() {
				@Override
				public void opened(ConnectionProfile profile) {
					if (profile.equals(SchemaChoicesModel.this.subject)) {
						collectionChanged();
					}
				}
				@Override
				public void schemaChanged(ConnectionProfile profile, Schema schema) {
					if (profile.equals(SchemaChoicesModel.this.subject)) {
						collectionChanged();
					}
				}
			};
		}

		
		// ************ AspectAdapter impl *************************************
		
		@Override
		protected void engageSubject_() {
			// call 'super' last?
			this.defaultCatalogModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.catalogListener);
			super.engageSubject_();
		}

		@Override
		protected void disengageSubject_() {
			super.disengageSubject_();
			this.defaultCatalogModel.removePropertyChangeListener(PropertyValueModel.VALUE, this.catalogListener);
		}

		
		// ************ internal ***********************************************
		
		@Override
		protected Iterator<String> iterator_() {
			SchemaContainer sc = this.getSchemaContainer();
			return (sc == null) ? EmptyIterator.<String>instance() : sc.sortedSchemaIdentifiers();
		}

		private SchemaContainer getSchemaContainer() {
			return this.databaseSupportsCatalogs() ? this.getCatalog() : this.getDatabase();
		}

		private boolean databaseSupportsCatalogs() {
			Database db = this.getDatabase();
			return (db != null) && db.supportsCatalogs();
		}

		private Catalog getCatalog() {
			String name = this.defaultCatalogModel.getValue();
			return (name == null) ? null : this.getCatalog(name);
		}

		/**
		 * pre-condition: 'name' is not null
		 */
		private Catalog getCatalog(String name) {
			Database db = this.getDatabase();
			return (db == null) ? null : db.getCatalogForIdentifier(name);
		}

		private Database getDatabase() {
			return this.subject.getDatabase();
		}

	}
	
	


			PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.PROPERTIES_JAVA_PERSISTENCE_CONNECTION);
			
			// connection
			Combo connectionCombo = createCombo(group, 3, true);
			
			ComboModelAdapter.adapt(

					PropertyValueModel.VALUE,
					linkUpdateListener);

			// override default catalog
			Button overrideDefaultCatalogButton = createButton(
					group, 3, 
					JptUiMessages.JpaFacetWizardPage_overrideDefaultCatalogLabel, 

				JpaProjectPropertiesPage.this.overrideDefaultCatalogModel,
				defaultCatalogLabel, defaultCatalogCombo);
			
			// override default schema
			Button overrideDefaultSchemaButton = createButton(
					group, 3, 
					JptUiMessages.JpaFacetWizardPage_overrideDefaultSchemaLabel, 

	private class DiscoverAnnotatedClassesModel
		extends PropertyAspectAdapter<JpaProject, Boolean>
	{
		DiscoverAnnotatedClassesModel(PropertyValueModel<JpaProject> jpaProjectModel) { 
			super(jpaProjectModel, JpaProject.DISCOVERS_ANNOTATED_CLASSES_PROPERTY);
		}
		

Lines 35-40 Link Here

(-)src/org/eclipse/jpt/ui/internal/wizards/JpaFacetWizardPage.java (-29 / +40 lines)
35	import org.eclipse.swt.widgets.Link;	35	import org.eclipse.swt.widgets.Link;
36	import org.eclipse.ui.PlatformUI;	36	import org.eclipse.ui.PlatformUI;
37	import org.eclipse.ui.help.IWorkbenchHelpSystem;	37	import org.eclipse.ui.help.IWorkbenchHelpSystem;
		38	import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
		39	import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelSynchHelper;
38	import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;	40	import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;
39	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent;	41	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent;
40	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;	42	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;
Lines 53-58 Link Here
53	}	55	}
54		56
55	@Override	57	@Override
		58	protected IDataModel getDataModel() {
		59	return super.getDataModel();
		60	}
		61
		62	protected DataModelSynchHelper getSynchHelper() {
		63	return this.synchHelper;
		64	}
		65
		66	@Override
56	protected Composite createTopLevelComposite(Composite parent) {	67	protected Composite createTopLevelComposite(Composite parent) {
57	Composite composite = new Composite(parent, SWT.NULL);	68	Composite composite = new Composite(parent, SWT.NULL);
58	GridLayout layout = new GridLayout();	69	GridLayout layout = new GridLayout();
Lines 80-93 Link Here
80	wc.addListener(	91	wc.addListener(
81	new IFacetedProjectListener() {	92	new IFacetedProjectListener() {
82	public void handleEvent( final IFacetedProjectEvent event ) {	93	public void handleEvent( final IFacetedProjectEvent event ) {
83	model.setProperty(RUNTIME, wc.getPrimaryRuntime());	94	getDataModel().setProperty(RUNTIME, wc.getPrimaryRuntime());
84	}	95	}
85	},	96	},
86	IFacetedProjectEvent.Type.PRIMARY_RUNTIME_CHANGED	97	IFacetedProjectEvent.Type.PRIMARY_RUNTIME_CHANGED
87	);	98	);
88	}	99	}
89		100
90	private Button createButton(Composite container, int span, String text, int style) {	101	Button createButton(Composite container, int span, String text, int style) {
91	Button button = new Button(container, SWT.NONE \| style);	102	Button button = new Button(container, SWT.NONE \| style);
92	button.setText(text);	103	button.setText(text);
93	GridData gd = new GridData();	104	GridData gd = new GridData();
Lines 96-102 Link Here
96	return button;	107	return button;
97	}	108	}
98		109
99	private Combo createCombo(Composite container, int span, boolean fillHorizontal) {	110	Combo createCombo(Composite container, int span, boolean fillHorizontal) {
100	Combo combo = new Combo(container, SWT.BORDER \| SWT.SINGLE \| SWT.READ_ONLY);	111	Combo combo = new Combo(container, SWT.BORDER \| SWT.SINGLE \| SWT.READ_ONLY);
101	GridData gd;	112	GridData gd;
102	if (fillHorizontal) {	113	if (fillHorizontal) {
Lines 128-145 Link Here
128		139
129	@Override	140	@Override
130	public boolean isPageComplete() {	141	public boolean isPageComplete() {
131	if (! super.isPageComplete()) {	142	if ( ! super.isPageComplete()) {
132	return false;	143	return false;
133	}	144	}
134	else {	145
135	IStatus status =model.validate();	146	IStatus status = this.model.validate();
136	if( status.getSeverity() == IStatus.ERROR){	147	if (status.getSeverity() == IStatus.ERROR) {
137	setErrorMessage( status.getMessage() );	148	this.setErrorMessage(status.getMessage());
138	return false;	149	return false;
139	};
140	setErrorMessage(null);
141	return true;
142	}	150	}
		151
		152	this.setErrorMessage(null);
		153	return true;
143	}	154	}
144		155
145	@Override	156	@Override
Lines 164-170 Link Here
164	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.DIALOG_JPA_PLATFORM);	175	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.DIALOG_JPA_PLATFORM);
165		176
166	platformCombo = createCombo(group, 1, true);	177	platformCombo = createCombo(group, 1, true);
167	synchHelper.synchCombo(platformCombo, PLATFORM_ID, null);	178	getSynchHelper().synchCombo(platformCombo, PLATFORM_ID, null);
168	}	179	}
169	}	180	}
170		181
Lines 221-227 Link Here
221	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.NEW_JPA_PROJECT_CONTENT_PAGE_DATABASE);	232	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.NEW_JPA_PROJECT_CONTENT_PAGE_DATABASE);
222		233
223	connectionCombo = createCombo(group, 3, true);	234	connectionCombo = createCombo(group, 3, true);
224	synchHelper.synchCombo(connectionCombo, CONNECTION, null);	235	getSynchHelper().synchCombo(connectionCombo, CONNECTION, null);
225	connectionCombo.addSelectionListener(	236	connectionCombo.addSelectionListener(
226	new SelectionAdapter() {	237	new SelectionAdapter() {
227	@Override	238	@Override
Lines 260-266 Link Here
260		271
261	addDriverLibraryButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_addDriverLibraryLabel, SWT.CHECK);	272	addDriverLibraryButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_addDriverLibraryLabel, SWT.CHECK);
262	addDriverLibraryButton.setSelection(false);	273	addDriverLibraryButton.setSelection(false);
263	synchHelper.synchCheckbox(addDriverLibraryButton, USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH, null);	274	getSynchHelper().synchCheckbox(addDriverLibraryButton, USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH, null);
264		275
265	driverLibraryLabel = new Label(group, SWT.LEFT);	276	driverLibraryLabel = new Label(group, SWT.LEFT);
266	driverLibraryLabel.setText(JptUiMessages.JpaFacetWizardPage_driverLibraryLabel);	277	driverLibraryLabel.setText(JptUiMessages.JpaFacetWizardPage_driverLibraryLabel);
Lines 269-281 Link Here
269	driverLibraryLabel.setLayoutData(gd);	280	driverLibraryLabel.setLayoutData(gd);
270		281
271	driverLibraryCombo = createCombo(group, 1, true);	282	driverLibraryCombo = createCombo(group, 1, true);
272	synchHelper.synchCombo(	283	getSynchHelper().synchCombo(
273	driverLibraryCombo, DB_DRIVER_NAME,	284	driverLibraryCombo, DB_DRIVER_NAME,
274	new Control[] {driverLibraryLabel});	285	new Control[] {driverLibraryLabel});
275		286
276	overrideDefaultCatalogButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_overrideDefaultCatalogLabel, SWT.CHECK);	287	overrideDefaultCatalogButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_overrideDefaultCatalogLabel, SWT.CHECK);
277	overrideDefaultCatalogButton.setSelection(false);	288	overrideDefaultCatalogButton.setSelection(false);
278	synchHelper.synchCheckbox(overrideDefaultCatalogButton, USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, null);	289	getSynchHelper().synchCheckbox(overrideDefaultCatalogButton, USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, null);
279		290
280	defaultCatalogLabel = new Label(group, SWT.LEFT);	291	defaultCatalogLabel = new Label(group, SWT.LEFT);
281	defaultCatalogLabel.setText(JptUiMessages.JpaFacetWizardPage_defaultCatalogLabel);	292	defaultCatalogLabel.setText(JptUiMessages.JpaFacetWizardPage_defaultCatalogLabel);
Lines 284-296 Link Here
284	defaultCatalogLabel.setLayoutData(gd);	295	defaultCatalogLabel.setLayoutData(gd);
285		296
286	defaultCatalogCombo = createCombo(group, 1, true);	297	defaultCatalogCombo = createCombo(group, 1, true);
287	synchHelper.synchCombo(	298	getSynchHelper().synchCombo(
288	defaultCatalogCombo, USER_OVERRIDE_DEFAULT_CATALOG,	299	defaultCatalogCombo, USER_OVERRIDE_DEFAULT_CATALOG,
289	new Control[] {defaultCatalogLabel});	300	new Control[] {defaultCatalogLabel});
290		301
291	overrideDefaultSchemaButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_overrideDefaultSchemaLabel, SWT.CHECK);	302	overrideDefaultSchemaButton = createButton(group, 3, JptUiMessages.JpaFacetWizardPage_overrideDefaultSchemaLabel, SWT.CHECK);
292	overrideDefaultSchemaButton.setSelection(false);	303	overrideDefaultSchemaButton.setSelection(false);
293	synchHelper.synchCheckbox(overrideDefaultSchemaButton, USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, null);	304	getSynchHelper().synchCheckbox(overrideDefaultSchemaButton, USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, null);
294		305
295	defaultSchemaLabel = new Label(group, SWT.LEFT);	306	defaultSchemaLabel = new Label(group, SWT.LEFT);
296	defaultSchemaLabel.setText(JptUiMessages.JpaFacetWizardPage_defaultSchemaLabel);	307	defaultSchemaLabel.setText(JptUiMessages.JpaFacetWizardPage_defaultSchemaLabel);
Lines 299-326 Link Here
299	defaultSchemaLabel.setLayoutData(gd);	310	defaultSchemaLabel.setLayoutData(gd);
300		311
301	defaultSchemaCombo = createCombo(group, 1, true);	312	defaultSchemaCombo = createCombo(group, 1, true);
302	synchHelper.synchCombo(	313	getSynchHelper().synchCombo(
303	defaultSchemaCombo, USER_OVERRIDE_DEFAULT_SCHEMA,	314	defaultSchemaCombo, USER_OVERRIDE_DEFAULT_SCHEMA,
304	new Control[] {defaultSchemaLabel});	315	new Control[] {defaultSchemaLabel});
305	}	316	}
306		317
307	private void openNewConnectionWizard() {	318	void openNewConnectionWizard() {
308	String connectionName = DTPUiTools.createNewConnectionProfile();	319	String connectionName = DTPUiTools.createNewConnectionProfile();
309	if (connectionName != null) {	320	if (connectionName != null) {
310	model.setProperty(CONNECTION, connectionName);	321	getDataModel().setProperty(CONNECTION, connectionName);
311	}	322	}
312	}	323	}
313		324
314	private void openConnectionProfile() {	325	void openConnectionProfile() {
315	ConnectionProfile cp = getConnectionProfile();	326	ConnectionProfile cp = getConnectionProfile();
316	if (cp != null) {	327	if (cp != null) {
317	cp.connect();	328	cp.connect();
318	model.setBooleanProperty(CONNECTION_ACTIVE, cp.isActive());	329	getDataModel().setBooleanProperty(CONNECTION_ACTIVE, cp.isActive());
319	updateConnectLink();	330	updateConnectLink();
320	}	331	}
321	}	332	}
322		333
323	private void updateConnectLink() {	334	void updateConnectLink() {
324	ConnectionProfile cp = this.getConnectionProfile();	335	ConnectionProfile cp = this.getConnectionProfile();
325	connectLink.setEnabled((cp != null) && cp.isDisconnected());	336	connectLink.setEnabled((cp != null) && cp.isDisconnected());
326	addDriverLibraryButton.setEnabled(cp != null);	337	addDriverLibraryButton.setEnabled(cp != null);
Lines 328-334 Link Here
328		339
329	private ConnectionProfile getConnectionProfile() {	340	private ConnectionProfile getConnectionProfile() {
330	// we just use the connection profile to log in, so go the the db plug-in	341	// we just use the connection profile to log in, so go the the db plug-in
331	return JptDbPlugin.instance().getConnectionProfileFactory().buildConnectionProfile(model.getStringProperty(CONNECTION));	342	return JptDbPlugin.instance().getConnectionProfileFactory().buildConnectionProfile(getDataModel().getStringProperty(CONNECTION));
332	}	343	}
333	}	344	}
334		345
Lines 348-357 Link Here
348	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.NEW_JPA_PROJECT_CONTENT_PAGE_CLASSPATH);	359	PlatformUI.getWorkbench().getHelpSystem().setHelp(group, JpaHelpContextIds.NEW_JPA_PROJECT_CONTENT_PAGE_CLASSPATH);
349		360
350	discoverClassesButton = createButton(group, 1, JptUiMessages.JpaFacetWizardPage_discoverClassesButton, SWT.RADIO);	361	discoverClassesButton = createButton(group, 1, JptUiMessages.JpaFacetWizardPage_discoverClassesButton, SWT.RADIO);
351	synchHelper.synchRadio(discoverClassesButton, DISCOVER_ANNOTATED_CLASSES, null);	362	getSynchHelper().synchRadio(discoverClassesButton, DISCOVER_ANNOTATED_CLASSES, null);
352		363
353	listClassesButton = createButton(group, 1, JptUiMessages.JpaFacetWizardPage_listClassesButton, SWT.RADIO);	364	listClassesButton = createButton(group, 1, JptUiMessages.JpaFacetWizardPage_listClassesButton, SWT.RADIO);
354	synchHelper.synchRadio(listClassesButton, LIST_ANNOTATED_CLASSES, null);	365	getSynchHelper().synchRadio(listClassesButton, LIST_ANNOTATED_CLASSES, null);
355	}	366	}
356	}	367	}
357		368
Lines 369-375 Link Here
369		380
370	createOrmXmlButton = new Button(group, SWT.CHECK);	381	createOrmXmlButton = new Button(group, SWT.CHECK);
371	createOrmXmlButton.setText(JptUiMessages.JpaFacetWizardPage_createOrmXmlButton);	382	createOrmXmlButton.setText(JptUiMessages.JpaFacetWizardPage_createOrmXmlButton);
372	synchHelper.synchCheckbox(createOrmXmlButton, CREATE_ORM_XML, null);	383	getSynchHelper().synchCheckbox(createOrmXmlButton, CREATE_ORM_XML, null);
373	}	384	}
374	}	385	}
375		386




 ******************************************************************************/
package org.eclipse.jpt.core.internal.facet;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;

import org.eclipse.jpt.db.DatabaseFinder;
import org.eclipse.jpt.db.JptDbPlugin;
import org.eclipse.jpt.db.Schema;
import org.eclipse.jpt.db.SchemaContainer;
import org.eclipse.jpt.utility.internal.CollectionTools;
import org.eclipse.jpt.utility.internal.StringTools;
import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
import org.eclipse.jst.common.project.facet.core.libprov.IPropertyChangeListener;
import org.eclipse.jst.common.project.facet.core.libprov.LibraryInstallDelegate;
import org.eclipse.osgi.util.NLS;

import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonMessages;
import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

public class JpaFacetDataModelProvider
	extends FacetInstallDataModelProvider
	implements JpaFacetDataModelProperties
{
	private LibraryInstallDelegate defaultLibraryProvider;

	/** cache the connection profile - change it whenever the user selects a different name */
	private ConnectionProfile connectionProfile;
	
	
	private static final String EJB_FACET_ID = IModuleConstants.JST_EJB_MODULE;

	private static final IStatus PLATFORM_NOT_SPECIFIED_STATUS = 
			buildErrorStatus(JptCoreMessages.VALIDATE_PLATFORM_NOT_SPECIFIED);
	

			buildInfoStatus(JptCoreMessages.VALIDATE_CONNECTION_NOT_CONNECTED);
	
	private static final IStatus USER_OVERRIDE_DEFAULT_CATALOG_NOT_SPECIFIED_STATUS = 
			buildErrorStatus(JptCoreMessages.VALIDATE_DEFAULT_CATALOG_NOT_SPECIFIED);
	
	private static final IStatus USER_OVERRIDE_DEFAULT_SCHEMA_NOT_SPECIFIED_STATUS = 
			buildErrorStatus(JptCoreMessages.VALIDATE_DEFAULT_SCHEMA_NOT_SPECIFIED);
	

			buildWarningStatus(JptCoreMessages.VALIDATE_RUNTIME_NOT_SPECIFIED);
	
	private static final IStatus RUNTIME_DOES_NOT_SUPPORT_EJB_30_STATUS = 
			buildWarningStatus(JptCoreMessages.VALIDATE_RUNTIME_DOES_NOT_SUPPORT_EJB_30);
	
	
	private LibraryInstallDelegate defaultLibraryProvider;
	
	
	/**
	 * required default constructor
	 */
	public JpaFacetDataModelProvider() {
		super();
	}

	
	@Override
	public Set<String> getPropertyNames() {
		@SuppressWarnings("unchecked") Set<String> propertyNames = super.getPropertyNames();

		propertyNames.add(CREATE_ORM_XML);
		return propertyNames;
	}


	// ********** properties **********

	private String getPlatformId() {
		return (String) this.getProperty(PLATFORM_ID);
	}
	
	private String getConnectionName() {
		return (String) this.getProperty(CONNECTION);
	}

	private boolean userWantsToAddDbDriverJarsToClasspath() {
		return this.getBooleanProperty(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH);
	}
	
	private String getDriverName() {
		return (String) this.getProperty(DB_DRIVER_NAME);
	}

	private boolean userWantsToOverrideDefaultCatalog() {
		return this.getBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG);
	}
	
	private String getUserOverrideDefaultCatalog() {
		return (String) this.getProperty(USER_OVERRIDE_DEFAULT_CATALOG);
	}

	private boolean userWantsToOverrideDefaultSchema() {
		return this.getBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA);
	}
	
	private String getUserOverrideDefaultSchema() {
		return (String) this.getProperty(USER_OVERRIDE_DEFAULT_SCHEMA);
	}

	private boolean discoverAnnotatedClasses() {
		return this.getBooleanProperty(DISCOVER_ANNOTATED_CLASSES);
	}

	private IFacetedProjectWorkingCopy getFacetedProjectWorkingCopy() {
		return (IFacetedProjectWorkingCopy) this.getProperty(FACETED_PROJECT_WORKING_COPY);
	}

	private IProjectFacetVersion getProjectFacetVersion() {
		return (IProjectFacetVersion) this.getProperty(FACET_VERSION);
	}

	private IRuntime getRuntime() {
		return (IRuntime) this.getProperty(RUNTIME);
	}

	private LibraryInstallDelegate getLibraryInstallDelegate() {
		return (LibraryInstallDelegate) this.getProperty(LIBRARY_PROVIDER_DELEGATE);
	}


	// ********** enabled **********

	@Override
	public boolean isPropertyEnabled(String propertyName) {
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return getBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG);
		}
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return getBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA);
		}
		if (propertyName.equals(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH)) {
			return (this.getConnectionProfile() != null);
		}
		if (propertyName.equals(DB_DRIVER_NAME)) {
			return this.userWantsToAddDbDriverJarsToClasspath();
		}

		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG)) {
			return this.connectionIsActive() && this.databaseSupportsCatalogs();
		}
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return this.userWantsToOverrideDefaultCatalog();
		}

		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.connectionIsActive();
		}
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.userWantsToOverrideDefaultSchema();
		}

		return super.isPropertyEnabled(propertyName);
	}


	// ********** defaults **********

	@Override
	public Object getDefaultProperty(String propertyName) {
		if (propertyName.equals(RUNTIME)) {

			return JptCorePlugin.getDefaultJpaPlatformId();
		}
		if (propertyName.equals(LIBRARY_PROVIDER_DELEGATE)) {
			return this.getDefaultLibraryProvider();
		}
		if (propertyName.equals(CONNECTION)) {
			return null;
		}
		if (propertyName.equals(CONNECTION_ACTIVE)) {
			return Boolean.valueOf(this.connectionIsActive());
		}
		if (propertyName.equals(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH)) {
			return Boolean.FALSE;
		}
		if (propertyName.equals(DB_DRIVER_NAME)) {
			return this.getDefaultDriverName();
		}
		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG)) {
			return Boolean.FALSE;
		}
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return this.getDefaultCatalogName();
		}
		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA)) {
			return Boolean.FALSE;
		}
		if (propertyName.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.getDefaultSchemaName();
		}
		if (propertyName.equals(DISCOVER_ANNOTATED_CLASSES)) {
			return Boolean.valueOf(this.runtimeSupportsEjb30());
		}
		if (propertyName.equals(LIST_ANNOTATED_CLASSES)) {
			return Boolean.valueOf( ! this.discoverAnnotatedClasses());
		}
		if (propertyName.equals(CREATE_ORM_XML)) {
			return Boolean.TRUE;

		
		return super.getDefaultProperty(propertyName);
	}

	private LibraryInstallDelegate getDefaultLibraryProvider() {
		// delegate itself changes, not the instance of delegate
		if (this.defaultLibraryProvider == null) {
			this.defaultLibraryProvider = this.buildDefaultLibraryProvider();
		}
		return defaultLibraryProvider;
	}
	
	private LibraryInstallDelegate buildDefaultLibraryProvider() {
		IFacetedProjectWorkingCopy fpjwc = this.getFacetedProjectWorkingCopy();
		if (fpjwc == null) {
			return null;
		}
		IProjectFacetVersion pfv = this.getProjectFacetVersion();
		if (pfv == null) {
			return null;
		}
		LibraryInstallDelegate lp = new LibraryInstallDelegate(fpjwc, pfv, this.buildEnablementVariables());
		lp.addListener(this.buildLibraryProviderListener());
		return lp;
	}

	private Map<String, Object> buildEnablementVariables() {
		Map<String, Object> enablementVariables = new HashMap<String, Object>();
		enablementVariables.put(JpaLibraryProviderConstants.EXPR_VAR_JPA_PLATFORM, this.getPlatformId());
		return enablementVariables;
	}

	private IPropertyChangeListener buildLibraryProviderListener() {
		return new IPropertyChangeListener() {
				public void propertyChanged(String property, Object oldValue, Object newValue ) {
					JpaFacetDataModelProvider.this.getDataModel().notifyPropertyChange(LIBRARY_PROVIDER_DELEGATE, IDataModel.VALUE_CHG);
				}
			};
	}

	private String getDefaultDriverName() {
		ConnectionProfile cp = this.getConnectionProfile();
		return (cp == null) ? null : cp.getDriverName();
	}

	private String getDefaultCatalogName() {
		Catalog catalog = this.getDefaultCatalog();
		return (catalog == null) ? null : catalog.getIdentifier();
	}

	private Catalog getDefaultCatalog() {
		Database db = this.getDatabase();
		return (db == null) ? null : db.getDefaultCatalog();
	}

	private String getDefaultSchemaName() {
		Schema schema = this.getDefaultSchema();
		if (cp == null) {
			return null;
		}
		Database db = cp.getDatabase();
		if (db == null) {
			return null;
		}
		Schema schema = db.getDefaultSchema();
		return (schema == null) ? null : schema.getIdentifier();
	}
	
	private Schema getDefaultSchema() {
		SchemaContainer sc = this.getSchemaContainer();
		return (sc == null) ? null : sc.getDefaultSchema();
			IFacetedProjectWorkingCopy fpjwc = (IFacetedProjectWorkingCopy) getProperty(FACETED_PROJECT_WORKING_COPY);
			IProjectFacetVersion fv = (IProjectFacetVersion) getProperty(FACET_VERSION);
			if (fpjwc != null && fv != null ) {
				Map<String, Object> enablementVariables = new HashMap<String, Object>();
				enablementVariables.put(
					JpaLibraryProviderConstants.EXPR_VAR_JPA_PLATFORM, 
					getPlatformId());	
				defaultLibraryProvider = new LibraryInstallDelegate(fpjwc, fv, enablementVariables);
				defaultLibraryProvider.addListener( 
					new IPropertyChangeListener() {
						public void propertyChanged(final String property, final Object oldValue, final Object newValue ) {
							JpaFacetDataModelProvider.this.model.notifyPropertyChange(LIBRARY_PROVIDER_DELEGATE, IDataModel.VALUE_CHG);
						}
					});
			}
		}
		return defaultLibraryProvider;
	}

	private boolean runtimeSupportsEjb30() {
		IRuntime runtime = this.getRuntime();
		return (runtime != null) && runtime.supports(this.getEJB30());
	}

	private IProjectFacetVersion getEJB30() {
		return ProjectFacetsManager.getProjectFacet(EJB_FACET_ID).getVersion("3.0"); //$NON-NLS-1$
	}


	// ********** synchronize data model **********

	@Override
	public boolean propertySet(String propertyName, Object propertyValue) {
		boolean ok = super.propertySet(propertyName, propertyValue);

		if (propertyName.equals(FACETED_PROJECT_WORKING_COPY)) {
			//no-op
		}
		else if (propertyName.equals(FACET_VERSION)) {
			this.model.notifyPropertyChange(LIBRARY_PROVIDER_DELEGATE, IDataModel.DEFAULT_CHG);
		}
		else if (propertyName.equals(RUNTIME)) {
			LibraryInstallDelegate lid = this.getLibraryInstallDelegate();
			if (lid != null) {
				// may be null while model is being built up
				// ... or in tests

			this.model.notifyPropertyChange(DISCOVER_ANNOTATED_CLASSES, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(LIST_ANNOTATED_CLASSES, IDataModel.DEFAULT_CHG);
		}
		else if (propertyName.equals(PLATFORM_ID)) {
			LibraryInstallDelegate lid = this.getLibraryInstallDelegate();
			if (lid != null) {
				// may be null while model is being built up
				// ... or in tests
				lid.setEnablementContextVariable(JpaLibraryProviderConstants.EXPR_VAR_JPA_PLATFORM, propertyValue);
					JpaLibraryProviderConstants.EXPR_VAR_JPA_PLATFORM,
					(String) propertyValue);
			}
		}
		else if (propertyName.equals(CONNECTION)) {
			this.setBooleanProperty(CONNECTION_ACTIVE, this.connectionIsActive());

			// db driver
			if (propertyValue == null) {  // connection set to '<None>'
				this.setBooleanProperty(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH, false);
			}
			this.model.notifyPropertyChange(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(DB_DRIVER_NAME, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(DB_DRIVER_NAME, IDataModel.VALID_VALUES_CHG);

			// catalog
			if ((propertyValue == null) || ! this.databaseSupportsCatalogs()) {  // connection set to '<None>' or "non-catalog" database
				this.setBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, false);
			}
			this.model.notifyPropertyChange(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_CATALOG, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_CATALOG, IDataModel.VALID_VALUES_CHG);

			// schema
			if (propertyValue == null) {  // connection set to '<None>'
				this.setBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, false);
			}
			this.model.notifyPropertyChange(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_SCHEMA, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_SCHEMA, IDataModel.VALID_VALUES_CHG);
		}
		else if (propertyName.equals(CONNECTION_ACTIVE)) {
			// catalog
			if (this.propertyValueIsFalse(propertyValue)) {  // connection is inactive
				this.setBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, false);
			}
			this.model.notifyPropertyChange(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_CATALOG, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_CATALOG, IDataModel.VALID_VALUES_CHG);

			// schema
			if (this.propertyValueIsFalse(propertyValue)) {  // connection is inactive
				this.setBooleanProperty(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, false);
			}
			this.model.notifyPropertyChange(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_SCHEMA, IDataModel.DEFAULT_CHG);
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_SCHEMA, IDataModel.VALID_VALUES_CHG);
			this.model.notifyPropertyChange(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH, IDataModel.ENABLE_CHG);
			this.model.notifyPropertyChange(DB_DRIVER_NAME, IDataModel.ENABLE_CHG);
		}
		else if (propertyName.equals(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH)) {
			this.model.notifyPropertyChange(DB_DRIVER_NAME, IDataModel.ENABLE_CHG);
			if (this.propertyValueIsFalse(propertyValue)) {
				this.setProperty(DB_DRIVER_NAME, null);
			}
		}
		else if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG)) {
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_CATALOG, IDataModel.ENABLE_CHG);
			if (this.propertyValueIsFalse(propertyValue)) {
				this.setProperty(USER_OVERRIDE_DEFAULT_CATALOG, null);
			}
		}
		else if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA)) {
			this.model.notifyPropertyChange(USER_OVERRIDE_DEFAULT_SCHEMA, IDataModel.ENABLE_CHG);
			if (this.propertyValueIsFalse(propertyValue)) {
				this.setProperty(USER_OVERRIDE_DEFAULT_SCHEMA, null);
			}
		}
		else if (propertyName.equals(DISCOVER_ANNOTATED_CLASSES)) {
			this.setBooleanProperty(LIST_ANNOTATED_CLASSES, this.propertyValueIsFalse(propertyValue));
//		}
//		if (propertyName.equals(USE_USER_JPA_LIBRARY)) {
//			this.model.setBooleanProperty(USE_SERVER_JPA_IMPLEMENTATION, ! ((Boolean) propertyValue).booleanValue());
//			this.model.notifyPropertyChange(JPA_LIBRARY, IDataModel.ENABLE_CHG);
//		}
		if (propertyName.equals(DISCOVER_ANNOTATED_CLASSES)) {
			this.model.setBooleanProperty(LIST_ANNOTATED_CLASSES, ! ((Boolean) propertyValue).booleanValue());
		}
		else if (propertyName.equals(LIST_ANNOTATED_CLASSES)) {
			this.setBooleanProperty(DISCOVER_ANNOTATED_CLASSES, this.propertyValueIsFalse(propertyValue));
		}
		return ok;
	}

	private boolean propertyValueIsFalse(Object propertyValue) {
		return ! this.propertyValueIsTrue(propertyValue);
	}

	private boolean propertyValueIsTrue(Object propertyValue) {
		return ((Boolean) propertyValue).booleanValue();
	}


	// ********** property descriptors **********

	@Override
	public DataModelPropertyDescriptor[] getValidPropertyDescriptors(String propertyName) {
		if (propertyName.equals(PLATFORM_ID)) {
			return this.buildValidPlatformDescriptors();
				CollectionTools.array(
					new TransformationIterator<String, DataModelPropertyDescriptor>(
						JpaPlatformRegistry.instance().jpaPlatformIds()) {
							@Override
							protected DataModelPropertyDescriptor transform(String platformId) {
								return platformIdPropertyDescriptor(platformId);
							}
						},
						EMPTY_DMPD_ARRAY),
				new Comparator<DataModelPropertyDescriptor>() {
					public int compare(DataModelPropertyDescriptor o1, DataModelPropertyDescriptor o2) {
						return (o1.getPropertyDescription().compareTo(o2.getPropertyDescription()));
					};
				});
		}

		if (propertyName.equals(CONNECTION)) {
			return this.buildValidConnectionDescriptors();
				new TransformationIterator<String, DataModelPropertyDescriptor>(
						new CompositeIterator<String>(null, connectionNames())) {
					@Override
					protected DataModelPropertyDescriptor transform(String next) {
						return connectionPropertyDescriptor(next);
					}
				},
				EMPTY_DMPD_ARRAY);
		}

		if (propertyName.equals(DB_DRIVER_NAME)) {
			return this.buildValidDriverDescriptors();
				new TransformationIterator<String, DataModelPropertyDescriptor>(driverNames()) {
					@Override
					protected DataModelPropertyDescriptor transform(String next) {
						return new DataModelPropertyDescriptor(next);
					}
				},
				EMPTY_DMPD_ARRAY);
		}

		if (propertyName.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return this.buildValidCatalogDescriptors();
				new TransformationIterator<String, DataModelPropertyDescriptor>(catalogNames()) {
					@Override
					protected DataModelPropertyDescriptor transform(String next) {
						return new DataModelPropertyDescriptor(next);
					}
				},
				EMPTY_DMPD_ARRAY);
		}

		if (propertyName.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.buildValidSchemaDescriptors();
				new TransformationIterator<String, DataModelPropertyDescriptor>(schemaNames()) {
					@Override
					protected DataModelPropertyDescriptor transform(String next) {
						return new DataModelPropertyDescriptor(next);
					}
				},
				EMPTY_DMPD_ARRAY);
		}

		return super.getValidPropertyDescriptors(propertyName);
	}

	private DataModelPropertyDescriptor[] buildValidPlatformDescriptors() {
		List<String> platformIDs = CollectionTools.list(JpaPlatformRegistry.instance().jpaPlatformIds());
		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[platformIDs.size()];
		for (int i = 0; i < descriptors.length; i++) {
			descriptors[i] = this.buildPlatformIdDescriptor(platformIDs.get(i));
		}
		return CollectionTools.sort(descriptors, this.buildDescriptorComparator());
	}

	/**
	 * sort the descriptors by 'description' (as opposed to 'value')
	 */
	private Comparator<DataModelPropertyDescriptor> buildDescriptorComparator() {
		return new Comparator<DataModelPropertyDescriptor>() {
				public int compare(DataModelPropertyDescriptor o1, DataModelPropertyDescriptor o2) {
					return (o1.getPropertyDescription().compareTo(o2.getPropertyDescription()));
				}
			};
	}

	private DataModelPropertyDescriptor[] buildValidConnectionDescriptors() {
		List<String> connectionNames = this.buildValidConnectionNames();
		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[connectionNames.size()];
		for (int i = 0; i < descriptors.length; i++) {
			descriptors[i] = this.buildConnectionDescriptor(connectionNames.get(i));
		}
		return descriptors;
	}

	/**
	 * put a null entry at the top of the list (for <none>)
	 */
	private List<String> buildValidConnectionNames() {
		List<String> connectionNames = CollectionTools.sort(CollectionTools.list(this.connectionProfileNames()));
		connectionNames.add(0, null);
		return connectionNames;
	}

	private DataModelPropertyDescriptor[] buildValidDriverDescriptors() {
		return new DataModelPropertyDescriptor[] { new DataModelPropertyDescriptor(this.getDriverName()) };
	}

	private DataModelPropertyDescriptor[] buildValidCatalogDescriptors() {
		Database db = this.getDatabase();
		return (db == null) ? EMPTY_DMPD_ARRAY : this.buildDescriptors(this.buildValidCatalogNames(db));
	}

	/**
	 * pre-condition: 'db' is not null
	 */
	private List<String> buildValidCatalogNames(Database db) {
		return this.buildValidStrings(db.sortedCatalogIdentifiers(), this.getDefaultCatalogName());
	}

	private DataModelPropertyDescriptor[] buildValidSchemaDescriptors() {
		Database db = this.getDatabase();
		return (db == null) ? EMPTY_DMPD_ARRAY : this.buildDescriptors(this.buildValidSchemaNames());
	}

	private List<String> buildValidSchemaNames() {
		return this.buildValidStrings(this.schemaNames(), this.getDefaultSchemaName());
	}

	private Iterator<String> schemaNames() {
		SchemaContainer sc = this.getSchemaContainer();
		return (sc == null) ? EmptyIterator.<String>instance() : sc.sortedSchemaIdentifiers();
	}

	/**
	 * put an entry for the default at the top of the list
	 */
	private List<String> buildValidStrings(Iterator<String> stream, String defaultString) {
		List<String> strings = CollectionTools.list(stream);
		if ((defaultString != null) && ! strings.contains(defaultString)) {
			strings.add(0, defaultString);
		}
		return strings;
	}

	private DataModelPropertyDescriptor[] buildDescriptors(List<String> strings) {
		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[strings.size()];
		for (int i = 0; i < descriptors.length; i++) {
			descriptors[i] = new DataModelPropertyDescriptor(strings.get(i));
		}
		return descriptors;
	}

	private static final DataModelPropertyDescriptor[] EMPTY_DMPD_ARRAY = new DataModelPropertyDescriptor[0];

	/**
	 * platform and connection have 'description's (in addition to 'value's)
	 */
	@Override
	public DataModelPropertyDescriptor getPropertyDescriptor(String propertyName) {
		if (propertyName.equals(PLATFORM_ID)) {
			return this.buildPlatformIdDescriptor(this.getPlatformId());
		}
		if (propertyName.equals(CONNECTION)) {
			return this.buildConnectionDescriptor(this.getConnectionName());
		}
		return super.getPropertyDescriptor(propertyName);
	}

	DataModelPropertyDescriptor buildPlatformIdDescriptor(String platformId) {
		return new DataModelPropertyDescriptor(platformId, this.getPlatformLabel(platformId));
			platformId, JpaPlatformRegistry.instance().getJpaPlatformLabel(platformId));
	}

	private String getPlatformLabel(String platformId) {
		return JpaPlatformRegistry.instance().getJpaPlatformLabel(platformId);
					new DataModelPropertyDescriptor(null, JptCoreMessages.NONE)
				:
					new DataModelPropertyDescriptor(connection);
	}

	private DataModelPropertyDescriptor buildConnectionDescriptor(String connectionName) {
		String description = (connectionName == null) ? JptCoreMessages.NONE : null;
		return new DataModelPropertyDescriptor(connectionName, description);
			return this.validatePlatformId(this.getStringProperty(name));
		}
		if (name.equals(LIBRARY_PROVIDER_DELEGATE)) {
			LibraryInstallDelegate delegate = (LibraryInstallDelegate) getProperty(LIBRARY_PROVIDER_DELEGATE);
		    return delegate.validate();
		}
		if (name.equals(CONNECTION)) {
			return this.validateConnectionName(this.getStringProperty(name));
		}
		if (name.equals(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH)
				|| name.equals(DB_DRIVER_NAME)) {
			return this.validateDbDriverName();
		}
		if (name.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG)
			|| name.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return this.validateUserOverrideDefaultCatalog();
		}
		if (name.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA)
				|| name.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.validateUserOverrideDefaultSchema();
		}
		if (name.equals(DISCOVER_ANNOTATED_CLASSES)) {
			return this.validatePersistentClassManagement(this.getBooleanProperty(name));
		}
		
		return super.validate(name);
	}


	// ********** database **********

	private SchemaContainer getSchemaContainer() {
		return this.databaseSupportsCatalogs() ? this.getCatalog() : this.getDatabase();
	}

	private Catalog getCatalog() {
		String name = this.getUserOverrideDefaultCatalog();
		return (name == null) ? null : this.getCatalog(name);
	}

	/**
	 * pre-condition: 'name' is not null
	 */
	private Catalog getCatalog(String name) {
		Database db = this.getDatabase();
		return (db == null) ? null : db.getCatalogForIdentifier(name);
	}

	private boolean databaseSupportsCatalogs() {
		Database db = this.getDatabase();
		return (db != null) && db.supportsCatalogs();
	}
	
	private Database getDatabase() {
		ConnectionProfile cp = this.getConnectionProfile();
		return (cp == null) ? null : cp.getDatabase();
	}

	private boolean connectionIsActive() {
		ConnectionProfile cp = this.getConnectionProfile();
		return (cp != null) && cp.isActive();
	}

	private ConnectionProfile getConnectionProfile() {
		String name = this.getConnectionName();
		return (name == null) ? null : this.getConnectionProfile(name);
	}

	/**
	 * pre-condition: 'name' is not null
	 */
	private ConnectionProfile getConnectionProfile(String name) {
		if (this.cachedConnectionProfileIsStale(name)) {
			this.connectionProfile = this.buildConnectionProfile(name);
		}
		return this.connectionProfile;
	}

	private boolean cachedConnectionProfileIsStale(String name) {
		return (this.connectionProfile == null) || ! this.connectionProfile.getName().equals(name);
	}

	private ConnectionProfile buildConnectionProfile(String name) {
		return this.getConnectionProfileFactory().buildConnectionProfile(name, DatabaseFinder.Default.instance());
	}

	private Iterator<String> connectionProfileNames() {
		return this.getConnectionProfileFactory().connectionProfileNames();
		return (cp != null) && cp.isActive();
	}
	
	private ConnectionProfileFactory getConnectionProfileFactory() {
		// we don't have a JPA project yet, so go to the db plug-in directly to get the factory
		return JptDbPlugin.instance().getConnectionProfileFactory();
		List<String> connectionNames = CollectionTools.sort(CollectionTools.list(
			this.getConnectionProfileFactory().connectionProfileNames()));
		
		if (! StringTools.stringIsEmpty(setValue) && ! connectionNames.contains(setValue)) {
			return new CompositeIterator<String>(setValue, connectionNames.iterator());
		}
		return connectionNames.iterator();
	}


	// ********** validation **********

	@Override
	public IStatus validate(String propertyName) {
		if (propertyName.equals(PLATFORM_ID)) {
			return this.validatePlatformId();
		}
		if (propertyName.equals(LIBRARY_PROVIDER_DELEGATE)) {
		    return this.getLibraryInstallDelegate().validate();
			return Collections.emptyList();
		}
		if (propertyName.equals(CONNECTION)) {
			return this.validateConnection();
	
	private Iterator<String> catalogNames() {
		String setValue = getStringProperty(USER_OVERRIDE_DEFAULT_CATALOG);
		List<String> catalogNames = this.buildSortedCatalogNames();
		
		if (StringTools.stringIsEmpty(setValue) || catalogNames.contains(setValue)) {
			return catalogNames.iterator();
		}
		if (propertyName.equals(USER_WANTS_TO_ADD_DB_DRIVER_JARS_TO_CLASSPATH)
				|| propertyName.equals(DB_DRIVER_NAME)) {
			return this.validateDbDriverName();
	private List<String> buildSortedSchemaNames() {
		ConnectionProfile cp = this.getConnectionProfile();
		if (cp == null) {
			return Collections.emptyList();
		}
		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_CATALOG)
				|| propertyName.equals(USER_OVERRIDE_DEFAULT_CATALOG)) {
			return this.validateUserOverrideDefaultCatalog();
		}
		if (propertyName.equals(USER_WANTS_TO_OVERRIDE_DEFAULT_SCHEMA)
				|| propertyName.equals(USER_OVERRIDE_DEFAULT_SCHEMA)) {
			return this.validateUserOverrideDefaultSchema();
		}
		if (propertyName.equals(DISCOVER_ANNOTATED_CLASSES)) {
			return this.validatePersistentClassManagement();
		
		if (StringTools.stringIsEmpty(setValue) || schemaNames.contains(setValue)) {
			return schemaNames.iterator();
		}
		return new CompositeIterator<String>(setValue, schemaNames.iterator());
	}
	
	private Iterator<String> driverNames() {
		String setValue = getStringProperty(DB_DRIVER_NAME);
		
		return super.validate(propertyName);
	}

	private IStatus validatePlatformId() {
		return (this.getPlatformId() == null) ? PLATFORM_NOT_SPECIFIED_STATUS : OK_STATUS;

	private IStatus validatePlatformId(String platformId) {
		return StringTools.stringIsEmpty(platformId) ?
				PLATFORM_NOT_SPECIFIED_STATUS
			:
				OK_STATUS;
	}

	private IStatus validateConnection() {
		String connectionName = this.getConnectionName();
		return (connectionName == null) ? OK_STATUS : this.validateNonNullConnection(connectionName);
	}
		ConnectionProfile connectionProfile = getConnectionProfile();
		if (connectionProfile == null) {
			return buildErrorStatus(NLS.bind(JptCoreMessages.VALIDATE_CONNECTION_INVALID, connectionName));
	
	private IStatus validateNonNullConnection(String connectionName) {
		ConnectionProfile cp = this.getConnectionProfile(connectionName);
		if (cp == null) {
			return buildErrorStatus(NLS.bind(JptCoreMessages.VALIDATE_CONNECTION_INVALID, connectionName));
		}
		if ( ! cp.isActive()) {
			return CONNECTION_NOT_CONNECTED_STATUS;
		}
		return OK_STATUS;
	}
	
	private IStatus validateDbDriverName() {
		return OK_STATUS;
	}

	private IStatus validateUserOverrideDefaultCatalog() {
		if (this.userWantsToOverrideDefaultCatalog()) {
			if (this.getUserOverrideDefaultCatalog() == null) {
				return USER_OVERRIDE_DEFAULT_CATALOG_NOT_SPECIFIED_STATUS;
			}
		}

	}
	
	private IStatus validateUserOverrideDefaultSchema() {
		if (this.userWantsToOverrideDefaultSchema()) {
			if (this.getUserOverrideDefaultSchema() == null) {
				return USER_OVERRIDE_DEFAULT_SCHEMA_NOT_SPECIFIED_STATUS;
			}
		}
		return OK_STATUS;
	}

	private IStatus validatePersistentClassManagement() {
		@SuppressWarnings("unused") boolean discoverAnnotatedClasses = this.discoverAnnotatedClasses();
		// TODO warning if "discovery" is used, but no runtime specified ??
		return OK_STATUS;
	}

	private IStatus validateDbDriverName() {
		return OK_STATUS;
	}


	// ********** static methods **********


		return buildStatus(IStatus.INFO, message);
	}

//	private static IStatus buildWarningStatus(String message) {
//		return buildStatus(IStatus.WARNING, message);
//	}

	private static IStatus buildErrorStatus(String message) {
		return buildStatus(IStatus.ERROR, message);

	private static IStatus buildStatus(int severity, String message) {
		return new Status(severity, JptCorePlugin.PLUGIN_ID, message);
	}

}

Lines 131-136 Link Here

(-)src/org/eclipse/jpt/core/internal/GenericJpaModel.java (+1 lines)
131	config.setProject(project);	131	config.setProject(project);
132	config.setJpaPlatform(JptCorePlugin.getJpaPlatform(project));	132	config.setJpaPlatform(JptCorePlugin.getJpaPlatform(project));
133	config.setConnectionProfileName(JptCorePlugin.getConnectionProfileName(project));	133	config.setConnectionProfileName(JptCorePlugin.getConnectionProfileName(project));
		134	config.setUserOverrideDefaultCatalogName(JptCorePlugin.getUserOverrideDefaultCatalogName(project));
134	config.setUserOverrideDefaultSchemaName(JptCorePlugin.getUserOverrideDefaultSchemaName(project));	135	config.setUserOverrideDefaultSchemaName(JptCorePlugin.getUserOverrideDefaultSchemaName(project));
135	config.setDiscoverAnnotatedClasses(JptCorePlugin.discoverAnnotatedClasses(project));	136	config.setDiscoverAnnotatedClasses(JptCorePlugin.discoverAnnotatedClasses(project));
136	return config;	137	return config;

Return to bug 267343