<?xml version="1.0" encoding="UTF-8"?>
<?NLS TYPE="org.eclipse.help.contexts"?>
<!-- /*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<contexts>
<!--DRES: Resource Selection Dialog-->
<context id="DRES0001">
<!--Resource Type drop down-->
<description>Select a resource from which to create a Web service.</description>
</context>
<context id="DRES0002">
<!--Resource tree-->
<description>Lists the resources that can be turned into a Web service.</description>
</context>


<context id="PPAD0004">
<!--  Hide generate client check box-->
<description>Select this check box to hide the option of generating a Web service client when you right-click a file in the Project Explorer or Navigator.</description>
</context>

<context id="PPAD0005">
<!--  Hide generate sample check box-->
<description>Select this check box to hide the option of generating sample JSP code for the Web service when you right-click a file in the Project Explorer or Navigator.</description>
</context>

<!--TopologyPreferencePage.java-->
<context id="PTPP0002">
<!--PTPP0002 for the Topology Preference Page-->
<description>This table respresents the the types of projects available into which you can generate a Web services client. You cannot add or remove project types, however you can change the order in which they appear in the Web services wizard. This is useful if you are creating several Web services that use the same type of client project because you can set that client project type as the default. To change the order, select a project type and use the up and down arrows to move it within the list. Changing the order of the list does not restrict your ability to select any of the options.</description>
</context>

<context id="PTPP0003">
<!--PTPP0002 for the Topology Preference Page-->
<description>Click this button to move the selected client project type towards the beginning of the list. This changes the order of the items in the client selection list and does not restrict your selection in any way.</description>
</context>

<context id="PTPP0004">
<!--PTPP0004 for the Topology Preference Page-->
<description>Click this button to move the selected client project type towards the end of the list. This changes the order of the items in the client selection list and does not restrict your selection in any way.</description>
</context>

<context id="PTPP0005">
<!--PTPP0002 for the Topology Preference Page-->
<description>If you select this check box, by default the Web services wizard will generate the Web services server and client code into different EARs. It is recommended that you enable this feature.</description>
</context>

<!--PPRM: Resource Management Preference page-->

<context id="PPRM0002">
<!--File overwrite check box-->
<description>The Resource Management preferences enable you to determine the defaults that you want to use when creating your Web service. Allows you to overwrite files without receiving a warning message asking for confirmation when overwriting files.</description>
</context>
<context id="PPRM0003">
<!--Create folders check box-->
<description>The Resource Management preferences enable you to determine the defaults that you want to use when creating your Web service. Select to create folders and folder structures without receiving a warning message asking for confirmation.</description>
</context>
<context id="PPRM0004">
<!--Check out files check box-->
<description>The Resource Management preferences enable you to determine the defaults that you want to use when creating your Web service. Select to check out files without receiving a warning message asking for confirmation.</description>
</context>


<!--PPSD: Scenario Defaults Preference page-->

<!--ScenarioDefaultsPreferencePage.java-->
<context id="PPSD0001">
<!--PPSD0001 for the Scenario Defaults Preference Page-->
<description>Use this page to select the default settings for the Web services wizard.</description>
</context>
<context id="PPSD0002">
<!--PPSD0002 for the launch sample check box on the Scenario Defaults Preference Page-->
<description>The Scenario Defaults preferences enable you to determine the defaults that you want to use when creating your Web service. The sample Web application demonstrates how to code the proxy file. Select this check box to launch sample application after it is created.</description>
</context>
<context id="PPSD0004">
<!--PPSD0004 for the sample JSP type combo box on the Scenario Defaults Preference Page-->
<description>Select the type of sample JSP to be created.</description>
</context>
<context id="PPSD0003">
<!--PPSD0003 for the web explorer type combo box on the Scenario Defaults Preference Page-->
<description>The Scenario Defaults preferences enable you to determine the defaults that you want to use when creating your Web service. Select from the available Web services explorers.</description>
</context>
<context id="PPSD0005">
<!--PPSD0005 for the User-defined UDDI Category Data Column Delimiter text field on the Scenario Defaults Preference Page-->
<description>Enter the character you want to use as a column delimiter for user-defined UDDI Category data.</description>
</context>
<context id="PPSD0006">
<!--PPSD0006 for the User-defined UDDI Category Data String Delimiter text field on the Scenario Defaults Preference Page-->
<description>Enter the character you want to use as a string delimiter for user-defined UDDI Category data.</description>
</context>


</contexts>