ACompleteEclipsePlatformWillBeDownloaded=An Eclipse platform will be downloaded. This can take several minutes and requires Internet access.
ANewRAPTargetWillBeCreated=A new RAP target will be created at '{0}'.
AServerBundleIsRequired=A server bundle is required.
ATemplateMustBeSelected=A Template must be selected.
ATestSection=A Test Section
AccessControlServices=Access Control Services
Action_PasteColumnWidths=Paste Column Widths
Action_PasteColumnWidths_InvalidClipboard=The clipboard does not contain valid column widths information.
Action_deleteNameX=Are you sure you want to delete '{0}'?
Action_deleteTypeX=Delete {0}...
Action_moveTypeX=Move {0}...
Action_newTypeConcreteX=New {0}
Action_newTypeX=New {0}...
Add=Add
AddExistingPage=Add Existing Page...
AddIgnoreAnnotation=Add ignore annotation for '{0}'.
AddIgnoreAnnotationPlural=Add ignore annotation for all bindings.
AddLibraryBundlesOperationName=Add libraries '{0}'...
AddOneMoreColumn=Add one more column?
AddOutline=Add Outline
AddTo=Add To
AdvancedOperations=Advanced Operations
AdvancedProperties=Advanced Properties
AllOutlinesTablePage=All Outlines
AllPages=All Pages
AlreadyExists=already exists
AnEmptyApplication=An empty Application.
AnErrorOccured=An error occurred. Check Error View for details.
AnOutlineMustBeSelected=An Outline must be selected.
ApplicationWithASingleForm=Application with a single Form.
ApplyEmptyTemplate=Apply empty Template...
ApplyOutlineTemplate=Apply Outline Template...
ApplySingleFormTemplate=Apply single Form Template...
ApplyVersion=Apply version to all plug-ins below.
Attributes=Attributes
AutoCreate=Auto Create
AutomaticallyCreateClassIdAnnotation=Automatically create the @ClassId annotation for new classes.
AvailableBundles=Available Bundles
BeanPropertyTablePage=Variables
BigdecimalField=Bigdecimal Field
BigintegerField=Biginteger Field
BookmarkStorageService=Bookmark Storage Services
BookmarkStorageServiceLocation=Bookmark Storage Service Location
BooleanColumn=Boolean Column
Bundle=Bundle
BundleAlreadyExists=Bundle '{0}' already exists.
BundleImportDesc=Import an existing Workspace Bundle to a Scout Project.
BundleImportRestartMsg=You may need to restart Eclipse to see the imported plug-ins in the Scout Explorer.
BundleName=Bundle Name
BundleNameCanNotStartOrEndWithSpecialCharactersOrDigits=Bundle name cannot start or end with special characters or digits. Valid project names are similar to (e.g. 'org.eclipse.testapp').
BundleType=Bundle Type
BundleTypes=Show Bundle Types
CalculatingGraphForBundle=Processing Bundle '{0}'.
CalculatingScoutBundleGraph=Calculating Scout Bundle Graph
CalendarItemProducerTablePage=Calendar Item Providers
CalendarServiceLocation=Calendar Service Location
CalendarServices=Calendar Services
CancelButton=Cancel Button
ChangeTechnology=Change Technology
CheckFormDataAnnot=This element is not configured to have a form data.\r\nCheck the existence of the '@FormData' annotation and that it is configured accordingly (sdkCommand \= SdkCommand.CREATE).
CheckPageData=This element is not configured to have a page data.\r\nCheck the existence of the '@PageData' annotation and that the referenced class exists.
ChildPage=Child Page
ChildPages=Child Pages
ChooseATemplateForYourFormHandler=Choose a Template for your Form Handler.
ChooseATemplateForYourPage=Choose a Template for your Page.
ChooseATemplateForYourSequenceBox=Choose a Template for your Sequence Box.
ChooseATemplateForYourTableColumn=Choose a Template for your Table Column.
ChooseATemplateForYourToolButton=Choose a Template for your Tool Button.
ChooseMenuTypes=Choose Menu Types
ChooseProducts=Choose the preferred products.
ChooseTheTypesForMenu=Choose the types for menu '{0}'.
ClientBundleMissing=Client Bundle missing
ClientDownloadLocation=Client Download Location
ClientProductToInclude=Client Product to include
ClientServicesNodePage=Services
CodeId=Code Id
CodeIdMustBeNumeric=Code Id must be a Number (long).
CodeIdNotValid=Code Id is not valid for the given generic type.
CodeType=Code Type
CodeTypeDoesNotMatchGeneric=The selected CodeType does not match the given generic type.
CodeTypeIdDatatype=Datatype of CodeType Id
Column=Column
ColumnDeleteConfirmationMessage=Are you sure you want to delete these columns?
ColumnWidthPasteDifferentTable=The selected table ({0}) does not belong to the column names in the clipboard ({1}).
ColumnWidthPasteInvalidWidth=The clipboard contains an invalid column width ({0}). The process of changing the columns widths is cancelled.
ColumnWidthPasteNoTableInField=The selected table field does not contain a table where to apply the column widths.
ColumnWidthPasteNoTableInPage=The selected page does not contain a table where to apply the column widths.
ColumnWidthPasteUnsupportedSelection=The element currently selected is not supported for applying the column widths.
ConfigureScoutWorkingSets=Configure Working Sets
Content=Content
Copied=copied
CopyOf=CopyOf
CreateANewBigdecimalField=Create a new Bigdecimal Field.
CreateANewBigintegerField=Create a new Biginteger Field.
CreateANewBookmarkStorageService=Create a new Bookmark Storage Service.
CreateANewBooleanField=Create a new Boolean Field.
CreateANewButtonField=Create a new Button.
CreateANewCalendarField=Create a new Calendar Field.
CreateANewCalendarFormHandler=Create a new Calendar Form Handler.
CreateANewCalendarItemProvider=Create a new Calendar Item Provider.
CreateANewCalendarService=Create a new Calendar Service.
CreateANewCheckboxField=Create a new Checkbox Field.
CreateANewClientService=Create a new Client Service.
CreateANewCode=Create a new code.
CreateANewCodeType=Create a new Code Type.
CreateANewComposerField=Create a new Composer Field.
CreateANewComposerFieldAttribute=Create a new Composer Field Attribute.
CreateANewComposerFieldEntity=Create a new Composer Field Entity.
CreateANewCustomService=Create a new Custom Service.
CreateANewDateField=Create a new Date Field.
CreateANewDefaultField=Create a new Default Field.
CreateANewDoubleField=Create a new Double Field.
CreateANewForm=Create a new Form.
CreateANewGroupBox=Create a new Group Box.
CreateANewHTMLField=Create a new HTML Field.
CreateANewIntegerField=Create a new Integer Field.
CreateANewKeyStroke=Create a new Key Stroke.
CreateANewLabelField=Create a new Label Field.
CreateANewListBoxField=Create a new List Box Field.
CreateANewLocalLookupCall=Create a new Local Lookup Call.
CreateANewLongField=Create a new Long Field.
CreateANewLookupCall=Create a new Lookup Call.
CreateANewLookupService=Create a new Lookup Service.
CreateANewMailField=Create a new Mail Field.
CreateANewMenu=Create a new Menu.
CreateANewOutline=Create a new Outline.
CreateANewOutlineService=Create a new Outline Service.
CreateANewOutlineToolButton=Create a new Outline Tool Button.
CreateANewPage=Create a new Page.
CreateANewPermission=Create a new Permission.
CreateANewPlannerField=Create a new Planner Field.
CreateANewProcessService=Create a new Service.
CreateANewProposalField=Create a new Proposal Field.
CreateANewRadioButton=Create a new Radio Button.
CreateANewRadioButtonGroup=Create a new Radio Button Group.
CreateANewSMTPService=Create a new SMTP Service.
CreateANewSQLService=Create a new SQL Service.
CreateANewSearchForm=Create a new Search Form.
CreateANewSequenceBox=Create a new Sequence Box.
CreateANewServiceOperation=Create a new Service Operation.
CreateANewSmartField=Create a new Smart Field.
CreateANewSmartTableColumn=Create a new Smart Table Column.
CreateANewStringField=Create a new String Field.
CreateANewTabBox=Create a new Tab Box.
CreateANewTableColumn=Create a new Table Column.
CreateANewTableField=Create a new Table Field.
CreateANewToolButton=Create a new Tool Button.
CreateANewTreeBox=Create a new Tree Box.
CreateANewTreeField=Create a new Tree Field.
CreateANewWizard=Create a new Wizard.
CreateANewWizardStep=Create a new Wizard Step.
CreateANnewFileChooserField=Create a new File Chooser Field.
CreateANnewImageField=Create a new Image Field.
CreateAScoutProject=Create a Scout Project
CreateExternalFormData=Create external FormData
CreateFormId=Create form Id
CreateFragmentForLib=Create a fragment with the host bundle as the library user.
CreateLibraryBundleOperationName=Create library bundle '{0}'.
CreateMissingClassIdAnnotations=Create missing @ClassId annotations
CreateMoreColumn=Create one more column
CreateNewRAPTarget=Create new RAP Target
CreateNewScoutBundles=Create new Scout Bundles
CreatePermission=CreatePermission
CreatePluginForLib=Create a plug-in to be referenced from library users.
CreateScoutProjectHelpMsg=Create a Scout project in the workspace.\nEnter the name and choose the desired tiers.
CreateSearchForm=Create Search Form...
CreateSystemFragmentForLib=Create a fragment to the system bundle. The library can be used from any bundle.
CreateTemplate=Create template...
CreateTemplateOf=Create a Template of '{0}'.
CreatesAnAmptyScoutApplicaiton=Creates an empty Scout application.
CustomImplementation=Custom Implementation
CustomServiceLocation=Custom Service Location
CustomServices=Custom Services
DatatypeOfNestedCodeIds=Datatype of nested Code Ids
DateColumn=Date Column
DefaultPackageIsDiscouraged=\ The use of the default package is discouraged.
Delete=Delete
DeleteAction_ensureRequest=Do you really want to delete '{0}'?
DeleteAction_ensureRequestPlural=Do you really want to delete these items?
DeleteForm=Delete Form...
DeleteFormField=Delete Form Field
DeleteLookupCall=Delete Lookup Call
DeleteTextProviderService=All translation resources referenced by this Text Provider Service are deleted as well. Do you want to continue?
DeleteTextProviderServicePlural=All translation resources referenced by these Text Provider Services are deleted as well. Do you want to continue?
DeleteWithPopup=Delete...
DependencyLoopDetected=Dependency loop detected
DesktopExtensionNodePage=Desktop-Extension
DesktopNodePage=Desktop
Dialog_propertyBean_typeLabel=Bean type
Dialog_rename_oldNameLabel=Name
DoNotShowAgain=Do not show again.
Documentation=Documentation
DoubleColumn=Double Column
Down=Down
DownloadEclipsePlatformAsWell=Download a new Luna Eclipse platform as well.
DownloadRAPTarget=Download RAP Target
DuplicateClassIdValue=Duplicate @ClassId value '{0}' in type '{1}'.
EarFileName=EAR File Name
EclipsePlatform=Eclipse Platform
Edit=Edit
EditContent=Edit Content...
EditDocumentation=Edit Documentation...
EditDocumentationForClass=Edit documentation for class '{0}'.
EmptyRapTargetVarFoundMsg=A target definition containing the '{0}' variable has been found in '{1}'.\r\nThis variable specifies the local path to the RAP plug-ins. In the current workspace this variable has not yet been initialized.\r\nWould you like to specify the location now?\r\n\r\nIf the variable is not configured correctly, the target definition may not work properly.\r\nThe value of the variable can also be changed in the preferences\: Window -> Preferences -> Run/Debug -> String Substitution
EnterColumnName=Enter a name of the {0} table column.
EnterFieldName=Enter a name of the {0} form field.
Entities=Entities
EntityTextField=Sub Package
EnumerationTablePage=Code Types
ErrorDetail=Error Detail
ErrorDuringCreatingPropertyPart=An Error occurred during creating property part.
Error_beanTypeNull=Bean type must be set.
Error_className=Please specify a class name.
Error_fieldNull=Field must have a class name.
Error_invalidFieldX=Invalid name.\nMust match to regex pattern {0}.
Error_nameAlreadyUsed=Name already used. Choose another name.
ExportAsEar=Export as Enterprise Archive (EAR)
ExportAsEarFile=Export as EAR file...
ExportAsWarFile=Export as WAR file...
ExportProductDesc=Exports the product as WAR file.
ExportRapAsWarFile=Export as WAR file...
ExportRapWebArchive=Export RAP Web Archive
ExportRapWebArchiveMessage=Exports a RAP UI product as WAR file. The export can be deployed directly to the webapps folder of a web server.
ExportScoutProject=Export a Scout Project
ExportScoutProjectMenu=Export Scout Project...
ExportScoutProjectMessage=Exports a Scout project.\r\nThe export can be deployed directly to an application- or web-server.
ExportToEAR=Export to an Enterprise Archive
ExportToWAR=Export to Web Archive
ExportWebArchive=Export Server Web Archive
ExportWebArchiveMessage=Exports a server product as WAR file.\r\nThe export can be deployed directly to the webapps folder of a web server.
ExportWebClientArchive=Export Client Application
FieldCanBeDeletedWithWriteMethod=The field can only be deleted together with the read and write method.
FieldDeleteConfirmation=Are you sure you want to delete this field?
FieldDeleteConfirmationPlural=Are you sure you want to delete these fields?
File=File
Filter=Filter
Find=Find
FindJavaReferences=Find Java references
FinishWizard=Finish wizard
Flat=Flat
FlatGroups=Flat Groups
Font=Font
FontDialogHelpMsg=Choose a font. Use default to ensure the default font value is taken.
Form=Form
FormClassLocations=Form Class Locations
FormData=FormData
FormDataDeleteWithForm=FormData '{0}' should be deleted together with the form.
FormField=Form Field
FormFieldDesc=Choose the type of form field.
FormFieldName=Form Field Name
FormFields=Form Fields
FormHandler=Form Handler
FormHandlerMODIFY=Form Handler MODIFY
FormHandlerNEW=Form Handler NEW
FormHandlerTemplates=Form Handler Templates
FormHandlersTablePage=Handlers
FormId=Form Id
FormTablePage=Forms
FormToStart=Form to start
FragmentHostBundleNotExists=Fragment host bundle does not exist.
FragmentHostBundleNotFound=Fragment host bundle cannot be null.
GenericType=Generic Type
GenericTypeCanNotBeNull=Please choose a generic type.
GenericTypeDoesNotMatchSuperClass=The selected generic type does not match the generic of the super class.
Global=global
GoTo=Go To
Grouped=Grouped
Hierarchical=Hierarchical
HolderPageOutline=Holder Page/Outline
HolderTypeIsMissing=Holder Type is missing.
IService=Service Interface
Icons=Icons
IdNameMissing=Please specify a property id name.
ImplementXInY=Implement '{0}' in '{1}'...
ImportBundle=Import Bundle
ImportPlugin=Import Plug-in...
IncludeClientApplication=Include Client Application
InstallRapTargetLater=I'll do it later
IntegerColumn=Integer Column
Inventory=Inventory
ItemsFound=items found
JARFileSelection=JAR file selection
KEY=KEY
KeepAssignedDocumentation=Migrate assigned documentation?
KeepCurrentTarget=Keep current Target ({0})
KeyStroke=Key Stroke
KeyStrokesTablePage=Keystrokes
KeyType=Key Type
Libraries=Libraries
LicDialogAcceptButton=I accept the terms of the license agreements
LicDialogContentLabel=License text\:
LicDialogDeclineButton=I do not accept the terms of the license agreements
LicDialogListLabel=Licenses\:
LicDialogMsg=The selected features will be downloaded and installed.\r\nPlease review and accept the licenses to continue.
LicDialogTitle=Review Licenses
LinkLibraryBundlePopup=Link existing library bundle...
LinkPage=Link Page
LinkPageToAPageHolder=Link Page to a Page Holder.
LinkWithEditor=Link Scout Explorer with Editor
Links=Links
Loading=Loading...
LoadingScoutExplorer=Loading Scout Explorer
LocalLookupCallTablePage=Local Lookup Calls
LocalRAPTarget=Existing RAP Target
LongColumn=Long Column
LongRunningOpConfirmationMsg=This operation can take several minutes. Do you want to continue?
LookupCall=Lookup Call
LookupCallDoesNotMatchGeneric=The selected LookupCall does not match the given generic type.
LookupCallLocations=Lookup Call Locations
LookupCallSuperType=Lookup Call Super Type
LookupCallTablePage=Lookup Calls
LookupService=Lookup Service
LookupServiceLocation=Lookup Service Location
LookupServiceSuperType=Lookup Service Super Type
LookupServiceTablePage=Lookup Services
MacOsXSwingWarningMessage=Starting the Swing Client in Mac OS X might fail on some systems.\r\n\r\nTo fix this go to the run configuration (Run -> Run Configurations...) and select the Swing Client in the tree on the left hand side.\r\nIn the 'Arguments' tab try the following\:\r\n- In the 'Program arguments' box\:\r\n    - remove '-ws ${target.ws}'\r\n- In the 'VM arguments' box\:\r\n    - remove '-Dorg.eclipse.swt.internal.carbon.smallFonts'\r\n    - remove '-XstartOnFirstThread'\r\n\r\nPlease note\: When the Swing Client is started from the .product file again (using the 'Launch...' links), this might undo the changes done to the launch configuration in the steps above\!
MacOsXSwingWarningTitle=Issues with Mac OS X and Swing Client
Member=Member
MenuTablePage=Menus
MethodName=Method name
ModelDataExistsConfirmationMessage=The data class '{0}' for '{1}' does not exist.\r\n Do you want to create it?
ModifyHandler=ModifyHandler
MoreElements=more
Moved=moved
Name=Name
NameAlreadyInUse=This name is already used\!
NameArg=Name Arg
NameNotValid=Name not valid.
NameXAlreadyUsed=Name '{0}' is already used. Choose another name.
New=New
NewAttribute=New Composer Field Attribute
NewBigdecimalField=New Bigdecimal Field
NewBigintegerField=New Biginteger Field
NewBookmarkService=New Bookmark Service
NewBookmarkStorageService=New Bookmark Storage Service
NewBooleanField=New Boolean Field
NewButtonField=New Button
NewCalendarField=New Calendar Field
NewCalendarItemProvider=New Calendar Item Provider
NewCalendarService=New Calendar Service
NewCancelButton=New Cancel Button
NewCheckboxField=New Checkbox Field
NewClientService=New Client Service
NewCode=New Code
NewCodeType=New Code Type
NewComposerField=New Composer Field
NewComposerFieldEntity=New Composer Field Entity
NewCustomService=New Custom Service
NewDateField=New Date Field
NewDefaultField=New Default Field
NewDesktopMenu=New Desktop Menu
NewDoubleField=New Double Field
NewFileChooserField=New File Chooser Field
NewForm=New Form
NewFormField=New Form Field
NewFormHandler=New Form Handler
NewGroupBox=New Group Box
NewHTMLField=New HTML Field
NewHandler=NewHandler
NewImageField=New Image Field
NewIntegerField=New Integer Field
NewKeyStroke=New Key Stroke
NewLabelField=New Label Field
NewLibraryBundle=New Library Bundle
NewLibraryBundleDesc=Creates a new library bundle containing custom JAR files.
NewLibraryBundlePopup=New Library Bundle...
NewListboxField=New Listbox Field
NewLocalLookupCall=New Local Lookup Call...
NewLocalLookupCallNoPopup=New Local Lookup Call
NewLongField=New Long Field
NewLookupCall=New Lookup Call
NewLookupService=New Lookup Service
NewMailField=New Mail Field
NewMenu=New Menu
NewOkButton=New Ok Button
NewOutline=New Outline
NewOutlineService=New Outline Service
NewOutlineToolButton=New Outline Tool Button
NewPage=New Page
NewPermission=New Permission
NewPlannerField=New Planner Field
NewProcessService=New Service
NewProperty=New Property
NewPropertyBean=New Property Bean
NewPropertyBeanDesc=Create a new Property Bean.
NewProposalField=New Proposal Field
NewRadioButton=New Radio Button...
NewRadioButtonGroup=New Radio Button Group
NewRadioButtonNoPopup=New Radio Button
NewSQLService=New SQL Service
NewScoutBundles=Add Scout Bundles...
NewScoutBundlesDesc=Adds new Scout Bundles to an existing Scout Project.
NewScoutProject=New Scout Project...
NewScoutProjectNoPopup=New Scout Project
NewScoutWorkingSet=New Scout Working Set
NewSearchForm=New Search Form
NewSequenceBox=New Sequence Box
NewServiceOperation=New Service Operation...
NewServiceOperationNoPopup=New Service Operation
NewSharedContextProperty=New Shared Context Property
NewSmartField=New Smart Field
NewSmartTableColumn=New Smart Table Column
NewSmtpService=New SMTP Service
NewStringField=New String Field
NewTabBox=New Tab Box
NewTableColumn=New Table Column
NewTableField=New Table Field
NewToolButton=New Tool Button
NewTreeBox=New Tree Box
NewTreeField=New Tree Field
NewWizard=New Wizard
NewWizardStep=New Wizard Step
NextStep=Next Steps
Nls_newProposal_name=New translated text...
NoClientEarWithoutServer=The client can only be exported if the server is exported as well.
NoClientExportLocationSpecified=No Client Export Location specified\!
NoClientProductFileSpecified=No Client Product file specified\!
NoClientSvcRegWithoutASvcInterf=The client service registration cannot be done without a service interface.
NoClientToAddAvail=No Client Product to add as download available.
NoClientWithoutAShared=A client bundle without a shared bundle cannot be created.
NoDesktopFound=No desktop found.
NoFieldSelected=No Field selected.
NoJarFilesSelected=No jar files selected.
NoNewXWithoutScoutBundle=Cannot create a new {0} without a Scout Bundle in the workspace.
NoProductFileSpecified=No Product file specified\!
NoPropertiesAvailable=No Properties available.
NoPropertiesAvailableForX=No Properties available for {0}
NoRAPTargetFoundUnder=No RAP target found under '{0}'.
NoRAPTargetLocationDefined=No RAP target location specified.
NoRAPTargetWillBeSet=No RAP target will be set. The created Scout project will not compile without a RAP target.
NoRapBeforeHelios=The RAP UI only supports Eclipse 3.6 or newer.
NoRapProductFileSpecified=No RAP Product file specified\!
NoRapWithoutClient=A RAP bundle without a client bundle cannot be created.
NoResourceServletFound=Could not find a ResourceServlet registration.\nEnsure to register a ResourceServlet with the two parameters [bundle-name, bundle-path].
NoScoutProjectForDefaultSuperClassMsg=Super class defaults are configured for each Scout project independently.\r\nCreate a Scout project first to change the super class defaults.
NoSwingWithoutClient=A swing bundle without a client bundle cannot be created.
NoSwtWithoutAClient=A SWT bundle without a client bundle cannot be created.
NoTargetSpecified=No target directory specified\!
NoWARFileSpecified=No WAR file specified\!
None=None
OkButton=Ok Button
OnlyOneOfCodeTypeOrLookupCallCanBeProcessed=Only one of Code Type or Lookup Call can be processed.
Open=open
OpenIconsEditor=Open Icons Editor
OpenNlsEditor=Open NLS Editor...
OperationName=Operation Name
OperationNameMissing=Operation Name missing.
Operation_addExportedPackage=add package to manifest exported packages...
Operation_removeExportedPackage=remove package from manifest exported packages...
Operations=Operations
OrganiseLocations=Use drag and drop to organize the locations. Some items may be copied by pressing the Ctrl button while dragging. Only selected items will be created.
OrganizeAllImports=Organize all Imports
Outline=Outline
OutlineColumnsTablePage=Columns
OutlineDeleteConfirmation=Are you sure you want to delete this outline?
OutlineServiceLocation=Outline Service Location
OutlineServiceTablePage=Outline Services
OutlineTablePage=Outlines
OutlineTemplateDesc=Creates an application with an Outline Tree on the left hand side and Table on the right hand side.
OutlineTreeAndTableForm=Outline Tree and Table Form.
OverrideComposerFieldTree=Override Composer Field Tree
OverridesTheComposerFieldsDefaultTree=Overrides the Composer Fields Default Tree.
OverwriteExistingWarFile=Overwrite existing WAR File
Package=Package
PackageNameNotValid=The package name is not valid.
PackageNotContainJavaKeyword=The package may not contain a reserved Java keyword\: '{0}'
PackageOnlyLowerCase=The package should contain only lower case characters.
Page=Page
PageData=Page Data
PageOutline=Page/Outline
PageTemplates=Page Templates
PageTypeIsMissing=Page Type is missing.
Pages=Pages
ParameterXIsNotValid=Parameter {0} is not valid.
Path=Path
PermissionTablePage=Permissions
PleaseChooseAKeyType=Please choose a key type.
PleaseChooseATargetPlatform=Please choose a target platform.
PleaseSelectEntry=Please select at least one entry\!
PleaseSpecifyAName=Please specify a name.
PleaseSpecifyASubPackage=Please specify a sub package.
PluginToImport=Plug-in to Import
Preview=Preview
ProcessServiceLocation=Service Location
ProcessServiceSelection=Service interface and implementation must have the same selection.
Process_deleteX=delete {0}...
Process_findReferencesX=Find references of {0}...
ProductFile=Product File
ProductFileSelectionWizardMsg=Please select the product files that should be extended with newly created bundles.
ProductLauncher=Product Launchers
ProductSelectionDialogTitle=Select Product
ProjectAlias=Project Alias
ProjectAliasHelp=The project alias is used for the servlet name and launcher names.
ProjectAliasMissing=Project Alias is not set.
ProjectName=Project Name
ProjectNameIsNotValid=Project name is not valid. Valid project names are similar to 'org.eclipse.testapp'.
ProjectNameMissing=Project Name is not set.
ProjectNameShouldContainOnlyLowerCaseCharacters=Project name should contain only lower case characters (e.g. 'org.eclipse.testapp').
ProjectPostfix=Project Postfix
ProjectPostfixIsNotValid=Project postfix is not valid.
ProjectProperties=Project Properties
ProjectVersion=Project Version
PropHeaderText=Header Text
PropLabel=Label
PropText=Text
PropTitle=Title
Properties=Properties
PropertyNameId=Property Name Id
PropertyViewConfig.Categories.Appearance=Appearance
PropertyViewConfig.Categories.Behavior=Behavior
PropertyViewConfig.Categories.BusinessLogic=Business Logic
PropertyViewConfig.Categories.Data=Data
PropertyViewConfig.Categories.Layout=Layout
PropertyViewConfig.Categories.Misc=Miscellaneous
ProposalField_checkBox_showAllProposals=Show all proposals
Question=Question
RAPTargetAlreadyExists=The selected directory already exists. All existing contents of this directory will be deleted and a new RAP target will be created at this location.
RAPTargetLocation=RAP Target location
RAPTargetNotInstallableInPlatform=The RAP target cannot be installed into the running platform.
RapTargetDownloadWizardPageTitle=Specify the Scout RAP Runtime Location
ReadPermission=ReadPermission
RebuildingScoutBundleGraph=Loading Scout Workspace
Refreshing=Refreshing...
Regex=Regex
RelocateFormField=Relocate Form Field
Remove=Remove
RemoveLibraryBundlePopup=Remove Library Bundle
RemoveXinY=Remove '{0}' in '{1}'...
RenameScoutWorkingSet=Rename Scout Working Set
RenameWithPopup=Rename...
ReturnType=Return Type
ReturnTypeMissing=Return Type missing.
RootNodeName=Scout Projects
Running=running
SMTPServiceLocation=SMTP Service Location
SMTPServices=SMTP Services
SQLServiceLocation=SQL Service Location
SaveFile=Save File
SaveTheFile=Save the file '{0}' to use property view.
ScoutApplicationTemplates=Scout Application Templates
ScoutBundlePresentation=Scout Bundle Presentation
ScoutProjectId=Scout Project Id
ScoutProjectLabel=Scout Project\:
ScoutSDKDefaultPackagePreferences=Specify the default sub package for new Scout elements.
ScoutSDKPreferences=General Preferences for the Scout SDK
ScoutSDKSuperTypePreferences=Specify the default super classes to use when creating new Scout elements.
SearchForm2=Search Form
SearchForm=SearchForm
SearchFormClassLocations=Search Form Class Locations
SearchFormData=SearchFormData
SearchFormTablePage=Search Forms
SearchHandler=SearchHandler
SelectEarFileName=Please select an EAR file name.
SelectFieldsToRemove=Please select the form fields to remove.
SelectProductsToModify=Select products to modify
SelectTablePageForSearchForm=Choose a table page to create a 'Search Form' for.
ServerServicesCommonNodePage=Common Services
ServerServicesNodePage=Services
ServerSession=Server Session
ServerSessionNotOnClasspath=The selected Server Session '{0}' is not on the classpath of the Service Registration bundle '{1}'.
Service=Service
ServiceLocation=Service Location
ServiceProxyRegistration=Service Proxy Registration
ServiceRegistration=Service Registration
SessionClass=Session Class
SetDefaultValue=Set Default Value
SharedContextTablePage=Shared Context Properties with {0}
ShowAllFields=Show All Fields
ShowAllTemplates=Show all Templates
ShowExternalBundles=Show External Bundles
ShowFragments=Show Fragments
ShowTestSection=Show Test Section
Sibling=Sibling
SingleFormTemplateDesc=Creates an application with a single Form 'DesktopForm' opening with the application start as a View.
SmartColumn=Smart Column
SomeActions=Some Actions
SpecifiesTheSessionClass=Specifies the Session Class that should be used in the Service that will be created.
SpecifyTheRAPTargetLocation=Specify the RAP Target Location
SqlServices=SQL Services
StartProduct=Start Product...
StartProductInDebugMode=Start Product in Debug Mode...
StepDeleteConfirmationMessage=Are you sure you want to delete this step?
StepDeleteConfirmationMessagePlural=Are you sure you want to delete these steps?
StopProduct=Stop Product...
StringColumn=String Column
SuperType=Super Class
TableColumnName=Table Column Name
TableColumnTemplates=Table Column Templates
TablePage=Table Page
TargetDirectory=Target Directory
Technologies=Technologies
TechnologyResourcesToModifyDesc=Specify the resources that should be modified.
TemplateAlreadyExists=Template already exists.
TemplateDesc=A Template is an abstract form field. To use this Template create a form field class extending the Template class.
TemplateName=Template Name
TemplateSupport=Template support
Templates=Templates
TextProviderServices=Text Provider Services
Texts=Texts
TheBundleNameContainsInvalidCharacters=The bundle name contains invalid characters. Valid bundle names are similar to (e.g. 'org.eclipse.testapp').
TheCurrentlyActiveTargetPlatformWillBeUsed=The currently active target platform will be used. The created Scout project may not compile if the active target platform is not complete.
TheLookupCallCanNotBeNull=Please choose a Lookup Call.
TheProjectNameMayNotContainAReservedJavaKeyword=The project name may not contain a reserved Java keyword\: '{0}'
TheRAPTargetWillBeDownloaded=The RAP target will be downloaded. This can take some minutes and requires Internet access.
TheSessionClassCanNotBeNull=Please choose a Session Class.
TheSuperTypeCanNotBeNull=Please choose a super class.
ThisClassIdHasADocumentationEntryAssigned=This @ClassId has a documentation entry assigned.\r\nWould you like to update this entry to the new value?\r\n\r\nIf yes, the existing documentation entry will be updated with the new @ClassId value this class will receive.\r\nIf no, the existing documentation entry will not be changed (and will therefore still point to other having the same value). This class will then no longer have a documentation.
ToolButtonTemplates=Tool Button Templates
ToolTablePage=Tools
Type=Type
TypeFilterText=type filter text
TypeName=Class Name
UndefinedState=undefined state
UnlinkLibraryBundlePopup=Unlink library
UnpackJarFiles=Unpack the JAR files in the library bundle.
Up=Up
UpdateAllFormdatas=Update all FormData Classes...
UpdateAllPageDataClasses=Update all PageData Classes...
UpdateFormData=Update FormData
UpdateModelDataAutomatically=Automatically update DTO classes
UpdatePageData=Update PageData
UpdatePermission=UpdatePermission
UpdatePresenterForX=Update Presenter for '{0}'...
UpdateWithNewClassIdValue=Update with new @ClassId value
UseDefault=use default
UseDefaultScoutJDTPreferences=Use default Scout JDT preferences
UseLegacyTargetPackage=Use Legacy Target Package
UseRegEx=Use RegEx
UseRegularExpression=Use Regular Expression
UseSessionInRegistration=Use {0}
UseTemplateFor=Use Template for '{0}'
ValidateSqlBindings=Validate FormData SQL Bindings
ValueType=Value Type
VersionApplyErr=The new version could not be stored for the following plugins\:
VersionApplySuccess=The new version has been applied successfully.
VersionApplyWrongFormat=The new version is not properly formatted.\nThe format is 'major.minor.micro.qualifier' (e.g.\: '12.5.1.qualifier').
WARFileAlreadyExists=WAR File already exists\!
WaitingForEclipsePDE=Loading Scout Workspace - Waiting for Eclipse PDE
WarExportDownloadClient=Exports the client application as ZIP file.
WarExportNoRapUiFound=No RAP UI product to deploy on a web server available.\r\nA deployable RAP UI product must contain the bundles\:\r\n- {0}\r\n- {1}
WarExportNoServerFound=No server product to deploy on a web server available.\nA deployable server product must contain the bundles\:\n- {0}\n- {1}
WarFile=WAR File
WarFileFolder=War File Folder
WarFileNameUsed=This WAR name is already used by another module.
Warning_notWellformedJavaName=Name should start with upper case.
Wellform=Wellform...
WellformAllCodeTypes=Wellform all Code Types...
WellformAllForms=Wellform all Forms...
WellformAllOutlines=Wellform all Outlines...
WellformAllSearchForms=Wellform all Search Forms...
WellformAllWizards=Wellform all Wizards...
WellformConfirmationMessage=Wellform can take several minutes do you want to continue?
WellformLookupCalls=Wellform all Lookup Calls...
WellformSharedBundle=Wellform Shared Bundle...
WellformWizard=Wellform Wizard...
WizardStepTablePage=Steps
WizardTablePage=Wizards
Wizard_checkboxNew_title=New Checkbox
Wizard_customFieldNew_message=Create a new Custom Field.
Wizard_htmlFieldNew_message=Create a new HTML Field.
Wizard_serviceBookmarkStorageNew_title=New Bookmark-Storage Service
Wizard_serviceReportDataColumnNew_message=Create a new Column.
WorkingSetOther=Other
WorkingSets=Working Sets
WorkingSetsMsg=The Working Sets will only be used when the Scout Bundle Presentation is set to 'Working Sets'.
XIsNotAClasspathOfY='{0}' is not on classpath of '{1}'. Use drag and drop to correct the locations.
XIsNotOnClasspathOfServiceY='{0}' is not on classpath of Service Registration in '{1}'. Use drag and drop to correct the locations.
c=Wellform all Pages...
currrent=currrent
debugging=debugging
recommended=recommended
