settingsHeading = Settings

fullName = Full Name
preferredEmail = Email Address
registeredOn = Registered
accountId = Account ID
showSiteHeader = Show Site Header
useFlashClipboard = Use Flash Clipboard Widget
copySelfOnEmails = CC Me On Comments I Write
displayPatchSetsInReverseOrder = Display Patch Sets In Reverse Order
displayPersonNameInReviewCategory = Display Person Name In Review Category
defaultContextFieldLabel = Default Context:
maximumPageSizeFieldLabel = Maximum Page Size:
dateFormatLabel = Date/Time Format:
contextWholeFile = Whole File
buttonSaveChanges = Save Changes

tabAccountSummary = Profile
tabPreferences = Preferences
tabWatchedProjects = Watched Projects
tabContactInformation = Contact Information
tabSshKeys = SSH Public Keys
tabHttpAccess = HTTP Password
tabWebIdentities = Identities
tabMyGroups = Groups
tabAgreements = Agreements

buttonShowAddSshKey = Add Key ...
buttonCloseAddSshKey = Close
buttonDeleteSshKey = Delete
buttonClearSshKeyInput = Clear
buttonAddSshKey = Add

userName = Username
password = Password
buttonSetUserName = Select Username
buttonChangeUserName = Change Username
buttonClearPassword = Clear Password
buttonGeneratePassword = Generate Password
linkObtainPassword = Obtain Password
invalidUserName = Username must contain only letters, numbers, _, - or .
invalidUserEmail = Email format is wrong.
sshKeyInvalid = Invalid Key
sshKeyAlgorithm = Algorithm
sshKeyKey = Key
sshKeyComment = Comment
sshKeyStatus = Status

sshHostKeyTitle = Server Host Key
sshHostKeyFingerprint = Fingerprint:
sshHostKeyKnownHostEntry = Entry for <code>~/.ssh/known_hosts</code>:

webIdStatus = Status
webIdEmail = Email Address
webIdIdentity = Identity
untrustedProvider = Untrusted
buttonDeleteIdentity = Delete
buttonLinkIdentity = Link Another Identity

addSshKeyPanelHeader = Add SSH Public Key
addSshKeyHelp = (<a href="http://help.github.com/key-setup-redirect" target="_blank">GitHub's Guide to SSH Keys</a>)
invalidSshKeyError = Invalid SSH Key
sshJavaAppletNotAvailable = Open Key Unavailable: Java not enabled

buttonWatchProject = Watch
defaultProjectName = Project Name
defaultFilter = branch:name, or other search expression
projects = All Watchable Projects
projectsClose = Close
buttonBrowseProjects = Browse
projectListOpen = Watch Selected project
watchedProjectName = Project Name
watchedProjectFilter = Only If
watchedProjectColumnEmailNotifications = Email Notifications
watchedProjectColumnNewChanges = New Changes
watchedProjectColumnAllComments = All Comments
watchedProjectColumnSubmittedChanges = Submitted Changes

contactFieldFullName = Full Name
contactFieldEmail = Preferred Email
contactPrivacyDetailsHtml = \
  <b>The following offline contact information is stored encrypted.</b><br />\
  <br />\
  Contact information will only be made available to administrators if it is \
  necessary to reach you through non-email based communication.  Received data \
  is stored encrypted with a strong public/private key pair algorithm, and \
  this site does not have the private key.  Once saved, you will be unable to \
  retrieve previously stored contact details.
contactFieldAddress = Mailing Address
contactFieldCountry = Country
contactFieldPhone = Phone Number
contactFieldFax = Fax Number
buttonOpenRegisterNewEmail = Register New Email ...
buttonSendRegisterNewEmail = Register
buttonCancel = Cancel
titleRegisterNewEmail = Register Email Address
descRegisterNewEmail = \
  <p>A confirmation link will be sent by email to this address.</p>\
  <p>You must click on the link to complete the registration and make the address available for selection.</p>


newAgreement = New Contributor Agreement
agreementStatus = Status
agreementName = Name
agreementStatus_EXPIRED = Expired
agreementStatus_NEW = Pending
agreementStatus_REJECTED = Rejected
agreementStatus_VERIFIED = Verified
agreementDescription = Description
agreementAccepted = Accepted

newAgreementSelectTypeHeading = Select an agreement type:
newAgreementNoneAvailable = No contributor agreements are configured.
newAgreementReviewLegalHeading = Review the agreement:
newAgreementReviewContactHeading = Review your contact information:
newAgreementCompleteHeading = Complete the agreement:
newAgreementIAGREE = I AGREE
newAgreementAlreadySubmitted = Agreement already submitted.
buttonSubmitNewAgreement = Submit Agreement

welcomeToGerritCodeReview = Welcome to Gerrit Code Review
welcomeReviewContact = Please review your contact information:
welcomeContactFrom = \
  <p>The following contact information was automatically obtained when \
  you signed-in to the site.  This information is used to display who \
  you are to others, and to send updates to code reviews you have either \
  started or subscribed to.</p>

welcomeUsernameHeading = Select a unique username:

welcomeSshKeyHeading = Register an SSH public key:
welcomeSshKeyText = \
  <p>Gerrit Code Review uses \
  <a href="http://en.wikipedia.org/wiki/Public-key_cryptography" target="_blank">public-key cryptography</a> \
  and \
  <a href="http://en.wikipedia.org/wiki/Secure_Shell" target="_blank">SSH</a> \
  to authenticate \
  you during git's push and pull commands to hosted projects.  Registering \
  your public key allows Gerrit to identify you whenever you connect through \
  SSH.</p>\
  <p>This step can also be completed at a later time.</p>

welcomeAgreementHeading = Complete a contributor agreement:
welcomeAgreementText = \
  <p>If you will be contributing code or documentation changes to projects \
  hosted here, please consider taking a minute to review and complete \
  a contributor agreement.</p>\
  <p>This step can also be completed at a later time.</p>
welcomeAgreementLater = Continue Without Agreement
welcomeContinue = Continue
