<?xml version="1.0" encoding="utf-8"?><?NLS type="org.eclipse.help.contexts"?><contexts><context id="csh_outer_container">
<description/>
</context>
<context id="APPCLIENT_NEW_APPCLIENT_WIZARD_PAGE1">
<description>Use this wizard to create an application client project.

On this page, name the application client project and select the workspace location to store the project files. You can also select a target runtime for the project and add the project to an enterprise application project.

</description>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/cjarch.html" label="J2EE architecture"/>
</context>
<context id="EAR_NEW_EAR_WIZARD_PAGE1">
<description>Use this wizard to create an enterprise application (EAR) project. An enterprise application project can contain one or more J2EE modules, including application client modules, EJB modules, Connector modules, or Web modules.

On this page, name the EAR application project and select the workspace location to store the project files. You can also select a target runtime for the project.

To add J2EE modules to the enterprise application project, click <b>Next</b>. If you do not want to add J2EE modules during the creation of the enterprise application project, click <b>Finish</b>.

J2EE modules can be added to an enterprise application project at any time. Once the enterprise application project has been created, right-click and select <b>Properties &gt; EAR modules</b> to add or delete EAR modules from the project.

</description>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/cjarch.html" label="J2EE architecture"/>
</context>
<context id="NEW_EAR_COMP_PAGE">
<description>Use this page to select the facets the project will have and the runtimes the project will support.

Select the check boxes under <b>Project Facet</b> to select the facets that the project will have. You can also change the default version level of each facet.

To see the runtimes that your new project will support, click <b>Show Runtimes</b>. The <b>Runtimes</b> field lists the available runtimes. Select the check boxes next to the runtimes that you want the new project to support. The <b>Project Facets</b> list shows only the facets supported by the selected runtimes, preventing you from selecting a facet that does not work on a selected runtime. You can also choose a preferred runtime by selecting a runtime and then clicking the <b>Make Preferred</b> button. The preferred runtime provides the classpath for the project.

You can save the settings for this project so you can create other projects with the same settings later. To save the settings for a project, set up the project on the Select Project Facets page, click the <b>Save</b> button, and type a name for the new preset. When you create a project later, you can select that preset from the <b>Presets</b> list.

</description>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/cjarch.html" label="J2EE architecture"/>
</context>
<context id="NEW_EAR_ADD_MODULES_PAGE">
<description>Use this page to select available J2EE modules to add to the new enterprise application. Click the <b>New Module</b> button to create new modules.

J2EE modules can be added to an enterprise application project at any time. Once the enterprise application project has been created, right-click and select <b>Properties &gt; EAR modules</b> to add or delete EAR modules from the project.

</description>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/cjarch.html" label="J2EE architecture"/>
</context>
<context id="EAR_NEW_MODULE_PROJECTS_PAGE">
<description>Use this page to create new J2EE modules to add to the new enterprise application. The wizard can generate a set of default J2EE modules or individual customized J2EE modules.</description>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/tjear.html" label="Creating an enterprise application project"/>
<topic href="../org.eclipse.jst.j2ee.doc.user/topics/cjarch.html" label="J2EE architecture"/>
</context>
<context id="EJB_NEW_EJB_WIZARD_PAGE1">
<description>Use this wizard to create an EJB project.

On this page, name the application client project and select the workspace location to store the project files. You can also select a target runtime for the project and add the project to an enterprise application project.

</description>
<topic href="../org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html" label="Creating EJB projects"/>
<topic href="../org.eclipse.jst.ejb.doc.user/topics/cearch.html" label="EJB architecture"/>
<topic href="../org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html" label="EJB client JAR projects"/>
</context>
<context id="EJB_NEW_EJB_WIZARD_PAGE2">
<description>Use this page to specify the name of the EJB client JAR module, as well as the name of the JAR file ( <b>Client JAR URI</b> ).



</description>
<topic href="../org.eclipse.jst.ejb.doc.user/topics/tecrtpro.html" label="Creating EJB projects"/>
<topic href="../org.eclipse.jst.ejb.doc.user/topics/ceclientjars.html" label="EJB client JAR projects"/>
</context>
<context id="JCA_NEWIZARD_PAGE1">
<description>Use this wizard to create a Connector project. The J2EE Connector Architecture (JCA) specifies how a J2EE application component accesses a connection-based resource.

On this page, name the Connector project and select the workspace location to store the project files. You can also select a target runtime for the project and add the project to an enterprise application project.

</description>
</context>
</contexts>