diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/context/persistence/PersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/context/persistence/PersistenceUnit.java
index c0b248c..929eec7 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/context/persistence/PersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/context/persistence/PersistenceUnit.java
@@ -827,6 +827,11 @@
 	 */
 	int findInsertLocationForMappingFileRef();
 	
+	/**
+	 * Add the given list of class names to the persistence.xml excluding 
+	 * those that already exist.
+	 */
+	void addClasses(Iterable<String> classNames, IProgressMonitor monitor);
 
 	// ********** validation **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
index 7d2742c..714e219 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
@@ -2181,6 +2181,34 @@
 		}
 		throw new IllegalArgumentException("Illegal type mapping key: " + key); //$NON-NLS-1$
 	}
+	
+	
+	// ********** add classes to persistence unit **********
+
+	public void addClasses(Iterable<String> classNames, IProgressMonitor monitor) {
+		SubMonitor sm = SubMonitor.convert(monitor, IterableTools.size(classNames));
+		for (String className : classNames) {
+			if(!classRefExists(className)) {
+				this.addSpecifiedClassRef(className);
+			}
+			sm.worked(1);
+		}
+		if (sm.isCanceled()) {
+			return;
+		}
+		
+		this.getXmlPersistenceUnit().sortClasses();
+		sm.worked(1);
+	}
+	
+	private boolean classRefExists(String className) {
+		for (ClassRef classRef : this.getSpecifiedClassRefs()) {
+			if( classRef.getClassName().equals(className)) {
+				return true;
+			}
+		}
+		return false;
+	}
 
 	// ********** misc **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.properties b/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.properties
index e8ce1ce..5804085 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.properties
+++ b/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.properties
@@ -62,6 +62,7 @@
 synchronizeClasses = Synchronize Class List
 makePersistent = Make Persistent...
 persistenceEditor = Persistence XML Editor
+addToPersistenceUnit = Add to Persistence Unit
 
 javaPersistenceNode = Java Persistence
 jpaNode = JPA
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.xml b/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.xml
index 231c989..707b64f 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.xml
+++ b/jpa/plugins/org.eclipse.jpt.jpa.ui/plugin.xml
@@ -360,6 +360,11 @@
 			categoryId="org.eclipse.jpt.jpa.ui.jpaMetadataConversionCommands">
 		</command>
 
+  <command
+        id="org.eclipse.jpt.jpa.ui.addToPersistenceUnit"
+        name="%addToPersistenceUnit">
+  </command>
+
 	</extension>
 
 
@@ -636,6 +641,27 @@
 			</activeWhen>
 		</handler>
 
+		<handler
+			commandId="org.eclipse.jpt.jpa.ui.addToPersistenceUnit"
+			class="org.eclipse.jpt.jpa.ui.internal.handlers.AddToPersistenceUnitHandler">
+			<enabledWhen>
+				<with variable="selection">
+					<count value="+"/>
+					<iterate>
+						<and>
+							<adapt type="org.eclipse.jdt.core.IJavaElement" />
+							<or>
+								<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
+								<instanceof value="org.eclipse.jdt.core.IType"/>
+								<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
+								<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
+							</or>
+						</and>
+					</iterate>
+				</with>
+			</enabledWhen>
+		</handler>
+		
 	</extension>
 
 
@@ -828,6 +854,12 @@
 				<visibleWhen checkEnabled="true"/>
 			</command>
 		</menuContribution>
+		
+		<menuContribution locationURI="popup:org.eclipse.jpt.jpa.ui.menu.JpaTools">
+			<command commandId="org.eclipse.jpt.jpa.ui.addToPersistenceUnit">
+				<visibleWhen checkEnabled="true"/>
+			</command>
+		</menuContribution>
 
 		<!-- contributions to the project configure menu -->
 		<menuContribution locationURI="popup:org.eclipse.ui.projectConfigure?after=additions">
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.ui/property_files/jpt_jpa_ui.properties b/jpa/plugins/org.eclipse.jpt.jpa.ui/property_files/jpt_jpa_ui.properties
index 2d371a6..50c6b0c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.ui/property_files/jpt_jpa_ui.properties
+++ b/jpa/plugins/org.eclipse.jpt.jpa.ui/property_files/jpt_jpa_ui.properties
@@ -12,6 +12,10 @@
 
 ACCESS_TYPE_COMPOSITE_ACCESS=Access:
 
+ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TEXT=No persistence.xml found in the project
+ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TITLE=Add Classes to Persistence Unit
+ADD_CLASSES_TO_PERSISTENCE_UNIT_TASK_NAME=Adding classes to persistence unit...
+
 ADD_TO_EAR_COMPOSITE_EAR_MEMBER_SHIP=EAR membership
 ADD_TO_EAR_COMPOSITE_ADD_TO_EAR_LABEL=&Add project to an EAR
 ADD_TO_EAR_COMPOSITE_EAR_PROJECT_LABEL=EAR pr&oject name:
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/JptJpaUiMessages.java b/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/JptJpaUiMessages.java
index c85addc..dafe0ea 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/JptJpaUiMessages.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/JptJpaUiMessages.java
@@ -23,6 +23,10 @@
 	}
 
 	public static String ACCESS_TYPE_COMPOSITE_ACCESS;
+	public static String ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TEXT;
+	public static String ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TITLE;
+	public static String ADD_CLASSES_TO_PERSISTENCE_UNIT_TASK_NAME;
+
 	public static String ADD_TO_EAR_COMPOSITE_EAR_MEMBER_SHIP;
 	public static String ADD_TO_EAR_COMPOSITE_ADD_TO_EAR_LABEL;
 	public static String ADD_TO_EAR_COMPOSITE_EAR_PROJECT_LABEL;
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/internal/handlers/AddToPersistenceUnitHandler.java b/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/internal/handlers/AddToPersistenceUnitHandler.java
new file mode 100644
index 0000000..1a7455e
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.jpa.ui/src/org/eclipse/jpt/jpa/ui/internal/handlers/AddToPersistenceUnitHandler.java
@@ -0,0 +1,346 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Oracle. 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:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.ui.internal.handlers;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.IWorkspaceRunnable;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jpt.common.core.resource.xml.JptXmlResource;
+import org.eclipse.jpt.common.ui.internal.swt.widgets.DisplayTools;
+import org.eclipse.jpt.common.ui.internal.utility.SynchronousUiCommandContext;
+import org.eclipse.jpt.common.utility.command.Command;
+import org.eclipse.jpt.common.utility.internal.ObjectTools;
+import org.eclipse.jpt.common.utility.internal.iterable.TransformationIterable;
+import org.eclipse.jpt.common.utility.internal.transformer.TransformerAdapter;
+import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.JpaProjectManager;
+import org.eclipse.jpt.jpa.core.context.persistence.Persistence;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceXml;
+import org.eclipse.jpt.jpa.ui.JptJpaUiMessages;
+import org.eclipse.jpt.jpa.ui.internal.plugin.JptJpaUiPlugin;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+public class AddToPersistenceUnitHandler extends AbstractHandler
+{
+	private IFile persistenceXmlFile;
+
+	public Object execute(ExecutionEvent event) throws ExecutionException {
+		ISelection selection = HandlerUtil.getCurrentSelectionChecked(event);
+
+		for (Map.Entry<IProject, Set<IType>> entry : this.buildSelectedTypes(selection).entrySet()) {
+			IProject project = entry.getKey();
+			Set<IType> types = entry.getValue();
+			JpaProject jpaProject = (JpaProject) project.getAdapter(JpaProject.class);
+			if (jpaProject != null) {
+				try {
+					PersistenceXml persistenceXml = jpaProject.getContextRoot().getPersistenceXml();
+					if (persistenceXml == null) {
+						MessageDialog.openInformation(DisplayTools.getShell(), JptJpaUiMessages.ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TITLE, JptJpaUiMessages.ADD_CLASSES_TO_PERSISTENCE_UNIT_MESSAGE_TEXT);
+					} else {
+						persistenceXmlFile = (IFile) persistenceXml.getResource();
+						IRunnableWithProgress runnable = new AddClassesRunnable(persistenceXmlFile, convertToTypeNames(types));
+						this.buildProgressMonitorDialog().run(true, true, runnable);  // true => fork; true => cancellable
+					}
+				} catch (InvocationTargetException ex) {
+					JptJpaUiPlugin.instance().logError(ex);
+				} catch (InterruptedException ex) {
+					Thread.currentThread().interrupt();
+					JptJpaUiPlugin.instance().logError(ex);
+				}
+			}
+		}
+		return null;
+	}
+	
+	protected Iterable<String> convertToTypeNames(Iterable<IType> types) {
+		return new TransformationIterable<IType, String>(types, new NameTransformer());
+	}
+	
+	/* CU private */ class NameTransformer
+		extends TransformerAdapter<IType, String> {
+		@Override
+		public String transform(IType type) {
+			return type.getFullyQualifiedName('$');
+		}
+	}
+
+	// ********** selected types **********
+
+	/**
+	 * Return a map containing lists of types, keyed by project.
+	 * <p>
+	 * The action is contributed for:<ul>
+	 * <li>{@link IType}
+	 * <li>{@link ICompilationUnit}
+	 * <li>{@link IPackageFragment}
+	 * <li>{@link IPackageFragmentRoot} that is a source folder
+	 * </ul>
+	 */
+	private Map<IProject, Set<IType>> buildSelectedTypes(ISelection currentSelection) {
+		if ( ! (currentSelection instanceof StructuredSelection)) {
+			return Collections.emptyMap();
+		}
+		HashMap<IProject, Set<IType>> types = new HashMap<IProject, Set<IType>>();
+		for (Object sel : ((StructuredSelection) currentSelection).toList()) {
+			switch (((IJavaElement) sel).getElementType()) {
+			case IJavaElement.PACKAGE_FRAGMENT_ROOT :
+				this.addSelectedTypes((IPackageFragmentRoot) sel, types);
+				break;
+			case IJavaElement.PACKAGE_FRAGMENT :
+				this.addSelectedTypes((IPackageFragment) sel, types);
+				break;
+			case IJavaElement.COMPILATION_UNIT :
+				this.addSelectedTypes((ICompilationUnit) sel, types);
+				break;
+			case IJavaElement.TYPE :
+				this.addSelectedType((IType) sel, types);
+				break;
+			default :
+				break;
+			}
+		}
+		return types;
+	}
+
+	private void addSelectedTypes(IPackageFragmentRoot packageFragmentRoot, Map<IProject, Set<IType>> types) {
+		for (IJavaElement pkgFragment : this.getPackageFragments(packageFragmentRoot)) {
+			this.addSelectedTypes((IPackageFragment) pkgFragment, types);
+		}
+	}
+
+	private void addSelectedTypes(IPackageFragment packageFragment, Map<IProject, Set<IType>> types) {
+		for (ICompilationUnit compUnit : this.getCompilationUnits(packageFragment)) {
+			this.addSelectedTypes(compUnit, types);
+		}
+	}
+
+	private void addSelectedTypes(ICompilationUnit compilationUnit, Map<IProject, Set<IType>> types) {
+		IType primaryType = compilationUnit.findPrimaryType();
+		if (primaryType != null) {
+			this.addSelectedType(primaryType, types);
+		}
+	}
+
+	private void addSelectedType(IType primaryType, Map<IProject, Set<IType>> typesMap) {
+		IProject project = primaryType.getJavaProject().getProject();
+		Set<IType> types = typesMap.get(project);
+		if (types == null) {
+			types = new HashSet<IType>();
+			typesMap.put(project, types);
+		}
+		types.add(primaryType);
+	}
+
+	private ICompilationUnit[] getCompilationUnits(IPackageFragment packageFragment) {
+		try {
+			return packageFragment.getCompilationUnits();
+		}
+		catch (JavaModelException e) {
+			JptJpaUiPlugin.instance().logError(e);
+		}
+		return new ICompilationUnit[0];
+	}
+
+	private IJavaElement[] getPackageFragments(IPackageFragmentRoot packageFragmentRoot) {
+		try {
+			return packageFragmentRoot.getChildren();
+		}
+		catch (JavaModelException e) {
+			JptJpaUiPlugin.instance().logError(e);
+		}
+		return new IJavaElement[0];
+	}
+
+	private ProgressMonitorDialog buildProgressMonitorDialog() {
+		return new ProgressMonitorDialog(null);
+	}
+
+	// ********** add classes runnable **********
+
+	/**
+	 * This is dispatched to the progress monitor dialog.
+	 */
+	/* CU private */ static class AddClassesRunnable implements IRunnableWithProgress
+	{
+		private final IFile persistenceXmlFile;
+		private final Iterable<String> typeNames;
+
+		AddClassesRunnable(IFile persistenceXmlFile, Iterable<String> typeNames) {
+			super();
+			this.persistenceXmlFile = persistenceXmlFile;
+			this.typeNames = typeNames;
+		}
+
+		public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+			try {
+				this.run_(monitor);
+			} catch (CoreException ex) {
+				throw new InvocationTargetException(ex);
+			}
+		}
+
+		private void run_(IProgressMonitor monitor) throws CoreException {
+			IWorkspace workspace = ResourcesPlugin.getWorkspace();
+			// lock the entire project, since we might modify the metamodel classes
+			ISchedulingRule rule = workspace.getRuleFactory().modifyRule(this.persistenceXmlFile.getProject());
+			workspace.run(
+					new AddClassesWorkspaceRunnable(this.persistenceXmlFile, typeNames),
+					rule,
+					IWorkspace.AVOID_UPDATE,
+					monitor
+					);
+		}
+	}
+
+
+	// ********** add classes workspace runnable **********
+
+	/**
+	 * This is dispatched to the Eclipse workspace.
+	 */
+	/* CU private */ static class AddClassesWorkspaceRunnable implements IWorkspaceRunnable
+	{
+		private final IFile persistenceXmlFile;
+		private final Iterable<String> typeNames;
+
+		AddClassesWorkspaceRunnable(IFile persistenceXmlFile, Iterable<String> typeNames) {
+			super();
+			this.persistenceXmlFile = persistenceXmlFile;
+			this.typeNames = typeNames;
+		}
+
+		public void run(IProgressMonitor monitor) throws CoreException {
+			if (monitor.isCanceled()) {
+				return;
+			}
+			SubMonitor sm = SubMonitor.convert(monitor, JptJpaUiMessages.ADD_CLASSES_TO_PERSISTENCE_UNIT_TASK_NAME, 20);
+
+			JpaProject jpaProject = this.getJpaProject();
+			if (jpaProject == null) {
+				return;
+			}
+
+			JptXmlResource resource = jpaProject.getPersistenceXmlResource();
+			if (resource == null) {
+				// the resource can be null if the persistence.xml file has an invalid content type
+				return;
+			}
+
+			if (sm.isCanceled()) {
+				return;
+			}
+			sm.worked(1);
+
+			PersistenceXml persistenceXml = jpaProject.getContextRoot().getPersistenceXml();
+			if (persistenceXml == null) {
+				return;  // unlikely...
+			}
+
+			Persistence persistence = persistenceXml.getRoot();
+			if (persistence == null) {
+				return;  // unlikely...
+			}
+
+			PersistenceUnit persistenceUnit = (persistence.getPersistenceUnitsSize() == 0) ?
+					persistence.addPersistenceUnit() :
+						persistence.getPersistenceUnit(0);
+					if (sm.isCanceled()) {
+						return;
+					}
+					sm.worked(1);
+
+					Command addClassesCommand = new AddClassesCommand(persistenceUnit, typeNames, sm.newChild(17));
+					JpaProjectManager mgr = this.getJpaProjectManager();
+					try {
+						if (mgr != null) {
+							mgr.execute(addClassesCommand, SynchronousUiCommandContext.instance());
+						}
+					} catch (InterruptedException ex) {
+						Thread.currentThread().interrupt();
+						throw new RuntimeException(ex);
+					}
+
+					resource.save();
+					sm.worked(1);
+		}
+
+		private JpaProjectManager getJpaProjectManager() {
+			return (JpaProjectManager) this.getWorkspace().getAdapter(JpaProjectManager.class);
+		}
+
+		private IProject getProject() {
+			return this.persistenceXmlFile.getProject();
+		}
+
+		private JpaProject getJpaProject() {
+			return (JpaProject) this.getProject().getAdapter(JpaProject.class);
+		}
+
+		private IWorkspace getWorkspace() {
+			return this.persistenceXmlFile.getWorkspace();
+		}
+	}
+
+
+	// ********** add classes command **********
+
+	/**
+	 * This is dispatched to the JPA project manager.
+	 */
+	/* CU private */ static class AddClassesCommand implements Command
+	{
+		private final PersistenceUnit persistenceUnit;
+		private final Iterable<String> typeNames;
+		private final IProgressMonitor monitor;
+
+		AddClassesCommand(PersistenceUnit persistenceUnit, Iterable<String> typeNames, IProgressMonitor monitor) {
+			super();
+			this.persistenceUnit = persistenceUnit;
+			this.typeNames = typeNames;
+			this.monitor = monitor;
+		}
+
+		public void execute() {
+			this.persistenceUnit.addClasses(typeNames, this.monitor);
+		}
+
+		@Override
+		public String toString() {
+			return ObjectTools.toString(this, this.persistenceUnit);
+		}
+	}
+}