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
reversePatchSetOrder = Display Patch Sets In Reverse Order
showUsernameInReviewCategory = 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
linkEditFullName = Edit
linkReloadContact = Reload
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_VERIFIED = Verified
agreementDescription = Description

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
