<?xml version="1.0" encoding="UTF-8"?>
<?NLS TYPE="org.eclipse.help.contexts"?>
<!-- /*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<contexts>
<!-- new v6 preference page-->
<context id="SRPF0001">
<description>Select the default Web server to be used for Web service creation.</description>
</context>
<context id="SRPF0002">
<!--runtime preference on the server runtime preference page-->
<description>Select the default server run-time environment to be used for Web service creation.</description>
</context>
<context id="SRPF0003">
<!--J2EE version preference on the server runtime preference page-->
<description>Select the default J2EE version to be used for Web service creation.</description>
</context>

<!-- new v6 handler wizard-->
<context id="AHDL0001">
<!--Handler config page-->
<description>Use this wizard to add and remove handlers for a Web service. The order in which they are listed represents the order in which the handlers will be acted upon.</description>
</context>

<!--WebServiceWizNewFirstPage-->
<context id="WSWSCEN0001">
<!-- First Page-->
<description>On this page select the artifact from which your Web client will be created, and the stages of Web services development that you want
to complete:
<ul>
<li>Develop: this will create the client code</li>
<li>Assemble: this ensures that the project that will host the 
client gets associated to an EAR when required by the target application server</li>
<li>Deploy: this will create the deployment code for the client</li>
<li>Install: this will install the client on the chosen server</li>
<li>Start: this will start the server once the client has been installed on it</li>
<li>Test: this will provide various options for testing the client</li>
</ul>
Select the server and runtime for your Web client, and whether or not you want to publish or monitor the service.
</description>
</context>

<context id="WSWSCEN0014">
<!--Monitor checkbox of the First Page-->
<description>Monitor the Web service: this will send the Web service traffic
through the TCP/IP Monitor, which allows you to watch the SOAP traffic generated
by the Web service and to test this traffic for WS-I compliance.</description>
</context>

<context id="WSWSCEN0020">
<!--Service implementation field of the First Page-->
<description>Enter the URI to the WSDL, WSIL, or HTML file that
will be used to generate the service</description>
</context>

<context id="WSWSCEN0022">
<!--Server link of the First Page-->
<description>Select your server: the default server is displayed. If you
want to deploy your service to a different server click the link to specify
a different server.</description>
</context>

<context id="WSWSCEN0023">
<!--runtime link of the First Page-->
<description>Select your runtime: the default runtime is displayed. If you
want to deploy your service to a different runtime click the link to specify
a different runtime.</description>
</context>

<context id="WSWSCEN0024">
<!--projects link of the First Page-->
<description>Select the service project: the project containing the project
selected in your workspace is displayed. To select a different project and
EAR click on the project link. Ensure that the project selected
as the Client Web Project is different from the Service Web Project, or the
service will be overwritten by the client's generated artifacts.</description>
</context>

<context id="WSWSCEN0025">
<!--client type combo of the First Page-->
<description>The Java bean client proxy that is generated provides a remote procedure call interface to the Web service.</description>
</context>

<context id="WSWSCEN0026">
<!--Client slider of the First Page-->
<description>Select the stages of Web services client development that you want
to complete using the slider:
<ul>
<li>Develop: this will create the client code</li>
<li>Assemble: </li>
<li>Deploy: this will create the deployment code for the client</li>
<li>Install: this will install the client on the chosen server</li>
<li>Start: this will start the server once the client has been installed on it</li>
<li>Test: this will provide various options for testing the client</li>
</ul></description>
</context>

<context id="WSWSCEN0030">
<!--file overwrite checkbox of the First Page-->
<description>This allows you to overwrite files without receiving a warning message asking for confirmation when overwriting files.</description>
</context>



<context id="WSIL0001">
<!--  WSIL Import Page-->
<description>Enter the required information to generate a standardized WSDL reference (WSIL) document in your project.</description>
</context>

<context id="WSIL0002">
<!--  WSIL Text field-->
<description>Enter the name of the WSIL document being generated, or accept the default.</description>
</context>

<context id="WSIL0003">
<!--  WSIL browse button-->
<description>Browse to the location of a WSDL or WSIL file from which the new WSIL document will be generated.</description>
</context>

<context id="WSIL0004">
<!--  WSIL table-->
<description>This lists all the WSDL URIs that will be included in the WSIL document.</description>
</context>

<context id="PWPR0001">
<!-- Project Page -->
<description>Select the type of Web service you want to generate and any file and folder options for your Web service.</description>
</context>

<context id="PWPR0003">
<!--Overwrite files without warning (checkbox)-->
<description>Allows you to overwrite files without receiving a warning message asking for confirmation when overwriting files.</description>
</context>

<context id="PWPR0004">
<!--Create folders when necessary (checkbox)-->
<description>Select to create folders and folder structures without receiving a warning message asking for confirmation.</description>
</context>

<context id="PWPR0005">
<!--  Generate Proxy check box of the Project Page -->
<description>The generated Java bean proxy provides a remote procedure call interface to the Web service.</description>
</context>

<context id="PWPR0006">
<!--  Test Proxy check box of the Project Page -->
<description>Select this check box to test the generated proxy.</description>
</context>

<context id="PWPR0009">
<!--  Start Web Project check box check box of the Project Page -->
<description>Click to start the server. If you leave the box unchecked you will have to manually start the server.</description>
</context>

<context id="PWPR0010">
<!-- Web Service Type combo box of the Project Page -->
<description>Select the type of Web service you want to build. Your selection will affect the files available for selection.</description>
</context>

<context id="PWPR0011">
<!--  Wizard Scenario Service group of the Project Page -->
<description>Select the type of Web service you want to build. Your selection will affect the files available for selection.</description>
</context>

<context id="PWPR0011">
<!--  Test service checkbox of the project page -->
<description>Select this check box to launch the Web service in the Web Services Explorer in order to examine it.</description>
</context>

<context id="PWPR0012">
<!--  Launch UDDI check box of the Project Page -->
<description>Select this checkbox to launch the Web Services Explorer in order to publish the Web service to a UDDI registry.</description>
</context>

<context id="PWPR0013">
<!--  Wizard Scenario Client group of the Project Page -->
<description>The generated Java bean proxy provides a remote procedure call interface to the Web service.</description>
</context>

<context id="PWPR0014">
<!--  Web Service Client Type combo box of the Project Page -->
<description>Select the client proxy type. The generated Java bean proxy provides a remote procedure call interface to the Web service.</description>
</context>

<context id="PWPR0015">
<!--  Check Out Files check box of the Project Page -->
<description>Select to check out files without receiving a warning message asking for confirmation.</description>
</context>


<!--WebServiceTPBeanClassPage.java-->
<context id="PBCL0001">
<!--PBCL0001 for the Bean Selection Page-->
<description>Use this page to select the Java bean or class used to create the Web service.</description>
</context>
<context id="PBCL0002">
<!--PBCL0002 for the Bean Selection field of the Bean Selection Page-->
<description>Enter the name of the Java bean to be used to create the Web service. Defaults the selected Java bean. Click <b>Browse classes </b>to view the bean class of the selected Java bean. The bean class is a model or template (an abstract data type) that can be instantiated to create objects with a common definition and therefore, common properties, operations, and behavior. Click <b>Browse files </b>to select a Java bean from the project.</description>
</context>
<context id="PBCL0003">
<!--PBCL0003 for the Bean Class Browse button of the Bean Selection Page-->
<description>Click to view the bean class of the selected Java bean.</description>
</context>
<context id="PBCL0004">
<!--PBCL0004 for the Bean Resource Browse button of the Bean Selection Page-->
<description>Browse to the correct Java bean to be used to create the Web service.</description>
</context>

<context id="PWPB0001">
<!--  UDDI Publish Page -->
<description>Select to launch the Web Services Explorer to allow you to publish the Web service.</description>
</context>

<context id="PWPB0002">
<!--  UDDI Launch check box of the UDDI Publish Page-->
<description>If selected will launch the Web Services Explorer to allow you to publish the Web service.</description>
</context>


<context id="PEBD0001">
<!-- EAR Projects drop-down box -->
<description>Select from the listed EAR projects.</description>
</context>

<context id="PEBD0002">
<!-- Table containing all of the bean names -->
<description>Select from the listed Java beans.</description>
</context>

<!--WebServiceTPBeanClassPage.java-->
<context id="PBCL0001">
<!--PBCL0001 for the Bean Selection Page-->
<description>Use this page to select the Java bean or class used to create the Web service.</description>
</context>

<context id="PBCL0002">
<!--PBCL0002 for the Bean Selection field of the Bean Selection Page-->
<description>Enter the name of the Java bean to be used to create the Web service. Defaults the selected Java bean. Click <b>Browse classes </b>to view the bean class of the selected Java bean. The bean class is a model or template (an abstract data type) that can be instantiated to create objects with a common definition and therefore, common properties, operations, and behavior. Click <b>Browse files </b>to select a Java bean from the project.</description>
</context>

<context id="PBCL0003">
<!--PBCL0003 for the Bean Class Browse button of the Bean Selection Page-->
<description>Click to view the bean class of the selected Java bean.</description>
</context>

<context id="PBCL0004">
<!--PBCL0004 for the Bean Resource Browse button of the Bean Selection Page-->
<description>Browse to the correct Java bean to be used to create the Web service.</description>
</context>


<context id="PCON0001">
<!-- WSDL Selection Page-->
<description>Use this page to select the WSDL, WSIL, or HTML document that will be used to create the Web service.</description>
</context>

<context id="PCON0002">
<!-- WSDL Document text field of the WSDL Selection Page-->
<description>Enter the path to a WSDL, WSIL, or HTML document.</description>
</context>

<context id="PCON0003">
<!-- WSDL Resource Browse button of the WSDL Selection Page-->
<description>Browse to the location of a WSDL, WSIL, or HTML document.</description>
</context>

<context id="PCON0004">
<!--  Generate WSIL button of the WSDL Selection Page-->
<description>Select this check box to generate a standardized WSDL reference (WSIL) document in your project.</description>
</context>

<context id="PCON0005">
<!--  WSIL Document text field of the WSDL Selection Page-->
<description>Enter the path to an existing WSIL document, or select the location where the WSIL document will be created.</description>
</context>

<context id="PCON0006">
<!--  WSIL Resource Browse button of the WSDL Selection Page-->
<description>Browse to the location of an existing WSIL document</description>
</context>

<context id="PWRS0001">
<!--  Run-time/servers in the Web Service type-->
<description>Select the scenario configuration for run-time environments, servers, and projects.</description>
</context>

<context id="PWRS0002">
<!--  Run-time/servers in the Web Service type-->
<description>Select the scenario configuration for run-time environments, servers, and projects.</description>
</context>

<context id="PWRS0004">
<!--  service-side run-time environment selection of the run-time environment selection Page-->
<description>This is the server-side run-time environment which the Web service will use.</description>
</context>

<context id="PWRS0005">
<!-- service-side server selection of the run-time environment selection Page-->
<description>This is the server-side server on which the Web service will run.</description>
</context>

<context id="PWRS0006">
<!--  service-side Web project combo box of the run-time environment selection Page-->
<description>Select the Web project or EJB project in which the Web service will be created. The wizard will create the Web project for you if it does not already exist. If you are using an EJB project, it must already exist.</description>
</context>

<context id="PWRS0007">
<!--service-side EJB project combo box of the run-time environment selection Page-->
<description>Select the EJB project in which the Web service will be created.</description>
</context>

<context id="PWRS0003">
<!--  client-side run-time environment selection of the run-time environment selection Page-->
<description>This is the client-side run-time environment which the Web service will use.</description>
</context>

<context id="PWRS0009">
<!-- client-side server selection of the run-time environment selection Page-->
<description>This is the client-side server on which the Web service will run.</description>
</context>

<context id="PWRS0010">
<!--  service-side Web project combo box of the run-time environment selection Page-->
<description>Select the project in which the Web service client will be created. The wizard will generate this project if it does not already exist.</description>
</context>

<context id="PWRS0011">
<!-- client type combo box of the server run-time environment selection Page -->
<description>Select from the listed project types the type of project that you want created to contain your Web service client.</description>
</context>

<context id="PWRS0012">
<!-- EAR combo box of the server run-time environment selection Page -->
<description>Select from the listed EAR projects. It is recommended that you select different EARs for the client and the service to avoid runtime errors. The wizard will create the EAR for you if it does not already exist.</description>
</context>


<context id="PWSM0001">
<!-- Sample Page -->
<description>The sample Web application demonstrates how to code the proxy file.</description>
</context>

<context id="PWSM0002">
<!-- Test check box of the Sample Page -->
<description>If selected will launch the sample Web application in the Web browser.</description>
</context>

<context id="PWSM0003">
<!-- Test Type Combo box of the Sample Page -->
<description>The sample Web application demonstrates how to code the proxy file.</description>
</context>

<context id="PWSM0005">
<!-- Methods tree of the Sample Page -->
<description>The methods that can be invoked on the service object and encoding styles for the method inputs and outputs. Only selected methods will be available for invocation and documented in the WSDL. Select encoding styles for input parameters and output return. The methods list will display supported methods for a selected service object.</description>
</context>

<context id="PWSM0006">
<!-- Select All button of the Sample Page -->
<description>Click this button to add all the available methods to the Web service sample proxy.</description>
</context>

<context id="PWSM0007">
<!-- Deselect All button of the Sample Page -->
<description>Click this button to remove all the available methods to the Web service sample proxy.</description>
</context>

<context id="PWSM0008">
<!-- JSP Folder field of the Sample Page -->
<description>Folder into which your Web service JSPs are deposited.</description>
</context>

<context id="PWSM0009">
<!-- JSP Folder Browse button of the Sample Page -->
<description>Click to find the folder into which your Web service JSPs are deposited.</description>
</context>

<context id="PWSM0010">
<!-- Project combo box of the Sample Page -->
<description>Select an existing project into which your sample will be generated.</description>
</context>

<context id="PWSM0014">
<!-- Folder field of the Sample Page -->
<description>Folder into which the fully qualified proxy is generated. Defaults to the source folder inside of your Web project.</description>
</context>

<context id="PWSM0015">
<!-- Run test check box of the Sample Page -->
<description>Select this check box to run the sample application on the server.</description>
</context>

<context id="PWSM0016">
<!-- EAR combo box of the Sample Page -->
<description>Select the EAR in which you want your Web service sample application created.</description>
</context>


<context id="PWWS0001">
<!--  WSDL Selection Page-->
<description>Use this page to select the WSDL, WSIL, or HTML document that will be used to create the Web service.</description>
</context>

<context id="PWWS0002">
<!--  WSDL Document text field of the WSDL Selection Page-->
<description>Enter the path to a WSDL, WSIL, or HTML document.</description>
</context>

<context id="PWWS0003">
<!--  WSDL Resource Browse button of the WSDL Selection Page-->
<description>Browse to the location of a WSDL, WSIL, or HTML document.</description>
</context>


<context id="DBAS0001">
<!-- HTTP basic authentication user name -->
<description>Enter the user name used for HTTP basic authentication.</description>
</context>

<context id="DBAS0002">
<!-- HTTP basic authentication password -->
<description>Enter the password used for HTTP basic authentication.</description>
</context>

<!--TopologyPreferencePage.java-->

<context id="PTPP0001">
<!--PTPP0001 for the Topology Preference Page-->
<description><p>These tables respresents the the types of projects available into which you can generate 
a Web service or 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 service or client project because you can set that service or 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.</p>
<p>If you select the 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.</p>
</description>
</context>

<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="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>


</contexts>
