################################################################################
# Copyright (c) 2006, 2011 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
################################################################################

AccessTypeComposite_access=Access:
AccessTypeComposite_field=Field
AccessTypeComposite_property=Property

AddToEarComposite_earMemberShip=EAR membership
AddToEarComposite_addToEarLabel=&Add project to an EAR
AddToEarComposite_earProjectLabel=EAR pr&oject name:
AddToEarComposite_newButtonLabel=New &Project ...

AddPersistentAttributeDialog_title=Add Attribute
AddPersistentAttributeDialog_attributeLabel=Attribute:
AddPersistentAttributeDialog_mappingLabel=Map as:
AddPersistentAttributeDialog_noMappingKeyError=You must specify a mapping type

AddPersistentClassDialog_title=Add Class
AddPersistentClassDialog_classLabel=Class:
AddPersistentClassDialog_classDialog_title=Persistent Class Selection
AddPersistentClassDialog_classDialog_message=Choose a class:
AddPersistentClassDialog_mappingLabel=Map as:
AddPersistentClassDialog_noClassError=You must specify a class
AddPersistentClassDialog_duplicateClassWarning=File already contains that persistent class
AddPersistentClassDialog_classNotFoundWarning=Cannot resolve class
AddPersistentClassDialog_noMappingKeyError=You must specify a mapping type

convertToJpa_convertingProject="Converting project to faceted form..."
convertToJpa_detectingTechnologies="Detecting existing technologies..."

DatabaseSchemaWizardPage_title=Database Schema
DatabaseSchemaWizardPage_desc=Select a database schema
DatabaseSchemaWizardPage_schemaSettings=Schema settings
DatabaseSchemaWizardPage_addConnectionToProject=<a>Add a connection to JPA project...</a>
DatabaseSchemaWizardPage_connectLink=<a>Connect</a>
DatabaseSchemaWizardPage_schema=Schema:
DatabaseSchemaWizardPage_connectionInfo=(Note: JPA project must have a connection and it must be active to select a schema)
DatabaseSchemaWizardPage_schemaInfo=(Note: Must have active connection to select schema)

Error_openingEditor=Error Opening Editor

General_browse=Br&owse...
General_revert=Revert
General_deselectAll=Deselect All
General_selectAll=Select All
General_refresh=Refresh Tables

GenerateDDLWizard_title=Generate Tables from Entities

GenerateEntitiesWizard_generateEntities=Generate Entities
GenerateEntitiesWizardPage_chooseEntityTable=Choose tables to generate entities from.
GenerateEntitiesWizardPage_generateEntities=Generate Entities from Tables
GenerateEntitiesWizardPage_synchronizeClasses=Synchronize classes in persistence.xml
GenerateEntitiesWizardPage_tables=Tables:
GenerateEntitiesWizardPage_tableColumn=Table
GenerateEntitiesWizardPage_entityNameColumn=Entity Name

EntitiesGenerator_jobName=Generating Entities

GenericPlatformUiDialog_notSupportedMessageTitle=Generate Tables from Entities
GenericPlatformUiDialog_notSupportedMessageText=Generate Tables from Entities is not supported by the Generic Platform

JpaContent_label=JPA Content

JpaStructureView_structureNotAvailable=JPA structure is not available.
JpaStructureView_linkWithEditorText=Link with Editor
JpaStructureView_linkWithEditorDesc=Link with Active Editor
JpaStructureView_linkWithEditorTooltip=Link with Editor
JpaStructureView_numItemsSelected={0} items selected

JpaDetailsView_viewNotAvailable=Details are not available for the current selection.

JpaFacetWizardPage_title=JPA Facet
JpaFacetWizardPage_description=Configure JPA settings.
JpaFacetWizardPage_platformLabel=&Platform
JpaFacetWizardPage_connectionLabel=&Connection
JpaFacetWizardPage_connectionLink=<a>Add connection...</a>
JpaFacetWizardPage_connectLink=<a>Connect</a>
JpaFacetWizardPage_connectedText=<a>Connected</a>
JpaFacetWizardPage_addDriverLibraryLabel=&Add driver library to build path
JpaFacetWizardPage_driverLibraryLabel=&Driver:
JpaFacetWizardPage_overrideDefaultCatalogLabel=&Override default catalog from connection
JpaFacetWizardPage_defaultCatalogLabel=Catalo&g:
JpaFacetWizardPage_overrideDefaultSchemaLabel=O&verride default schema from connection
JpaFacetWizardPage_defaultSchemaLabel=&Schema:
JpaFacetWizardPage_facetsPageLink=<a>Change JPA version...</a>
JpaFacetWizardPage_jpaImplementationLabel=JPA implementation
JpaFacetWizardPage_userServerLibLabel=Implementation provided by server runtime
JpaFacetWizardPage_specifyLibLabel=Implementation library:
JpaFacetWizardPage_jpaPrefsLink=<a>Configure default JPA implementation library...</a>
JpaFacetWizardPage_userLibsLink=<a>Configure user libraries...</a>
JpaFacetWizardPage_persistentClassManagementLabel=Persistent class management
JpaFacetWizardPage_discoverClassesButton=Discover annotated classes a&utomatically
JpaFacetWizardPage_listClassesButton=Annotated classes must be &listed in persistence.xml
JpaFacetWizardPage_createOrmXmlButton=Create &mapping file (orm.xml)
JpaFacetWizardPage_metamodelLabel=Canonical metamodel (JPA 2.0)
JpaFacetWizardPage_metamodelSourceFolderLink=<a>Source fol&der:</a>
JpaFacetWizardPage_none=<None>

JpaLibraryProviderInstallPanel_includeLibraries=&Include libraries with this application

JpaMakePersistentWizardPage_title=Make Persistent
JpaMakePersistentWizardPage_message=Make the selected Java classes persistent by selecting Java annotations or mapping file
JpaMakePersistentWizardPage_annotateInJavaRadioButton=Annotate in &Java
JpaMakePersistentWizardPage_mappingFileRadioButton=Add to &XML mapping file
JpaMakePersistentWizardPage_mappingFileLink=<a>&Mapping file:</a>
JpaMakePersistentWizardPage_mappingFileBrowseButton=B&rowse...
JpaMakePersistentWizardPage_typeTableColumn=Type
JpaMakePersistentWizardPage_mappingTableColumn=Mapping
JpaMakePersistentWizardPage_listInPersistenceXmlCheckBox=&List in persistence.xml
JpaMakePersistentWizardPage_selectedTypesPersistentError=All selected types are already persistent
JpaMakePersistentWizardPage_mappingFileDoesNotExistError=The XML mapping file does not exist
JpaMakePersistentWizardPage_mappingFileNotListedInPersistenceXmlError=The XML mapping file is not listed in the persistence.xml

JptPreferencesPage_DoNotShowDialogs=Dialogs
JptPreferencesPage_DoNotShowText=Clear all 'do not show again' settings and show all hidden dialogs again.
JptPreferencesPage_ClearButtonText=&Clear

JpaPreferencesPage_description=General settings for JPA development:
JpaPreferencesPage_jpqlEditor=JPQL Editing
JpaPreferencesPage_jpqlEditor_description=Specify the case for JPQL identifiers used with content assist.
JpaPreferencesPage_jpqlEditor_lowerCaseRadioButton=&Lowercase
JpaPreferencesPage_jpqlEditor_matchFirstCharacterCaseRadioButton=&Match Case of First Character
JpaPreferencesPage_jpqlEditor_upperCaseRadioButton=&Uppercase

JpaProblemSeveritiesPage_Description=Select the severity level for the following optional Java Persistence validation problems:
JpaProblemSeveritiesPage_Error=Error
JpaProblemSeveritiesPage_Ignore=Ignore
JpaProblemSeveritiesPage_Info=Info
JpaProblemSeveritiesPage_Warning=Warning

JpqlContentProposalProvider_Description=Content Assist Available ({0})
JpaJpqlJavaCompletionProposalComputer_Error=Can't retrieve JPQL proposals due to an internal error.
JpaJpqlSseCompletionProposalComputer_Error=Can't retrieve JPQL proposals due to an internal error.

MappingFileWizard_title=New Mapping File
MappingFileWizardPage_newFile_title=Mapping file
MappingFileWizardPage_newFile_desc=Specify mapping file name and location
MappingFileWizardPage_options_title=Mapping file
MappingFileWizardPage_options_desc=Specify mapping file options
MappingFileWizardPage_projectLabel=&Project:
MappingFileWizardPage_sourceFolderLabel=Source fol&der:
MappingFileWizardPage_filePathLabel=File pat&h:
MappingFileWizardPage_accessLabel=Default a&ccess:
MappingFileWizardPage_addToPersistenceUnitButton=&Add to persistence unit
MappingFileWizardPage_persistenceUnitLabel=Persistence &unit:
MappingFileWizardPage_incorrectSourceFolderError=Selection must be a valid source folder
MappingFileWizardPage_accessLabel_sourceFolderDialogTitle=Source Folder Selection
MappingFileWizardPage_accessLabel_sourceFolderDialogDesc=Choose a source folder:

JpaProjectWizard_title=New JPA Project
NewJpaProjectWizard_firstPage_title=JPA Project
NewJpaProjectWizard_firstPage_description=Configure JPA project settings.

OrmItemLabelProviderFactory_entityMappingsLabel=Entity Mappings

PersistenceItemLabelProviderFactory_persistenceLabel=Persistence

OverwriteConfirmerDialog_title=Overwrite Existing Class
OverwriteConfirmerDialog_text=Overwrite source code for the class ''{0}''?

SelectJpaOrmMappingFileDialog_newButton=New...
SelectJpaOrmMappingFileDialog_toolTip=Create a new mapping file
