settingsHeading = Settings

changeAvatar = Change Avatar
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
maximumPageSizeFieldLabel = Maximum Page Size:
commentVisibilityLabel = Comment Visibility:
dateFormatLabel = Date/Time Format:
contextWholeFile = Whole File
buttonSaveChanges = Save Changes
showRelativeDateInChangeTable = Show Relative Dates in Changes Table

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
addSshKeyHelpTitle = How to Generate an SSH Key
addSshKeyHelp = \
  <ol>\
    <li>\
      From the Terminal or Git Bash, run <em>ssh-keygen</em>\
    </li>\
    <li>\
      Confirm the default path <em>.ssh/id_rsa</em>\
    </li>\
    <li>\
      Enter a passphrase (recommended) or leave it blank.<br>\
      Remember this passphrase, as you will need it to unlock the<br>\
      key whenever you use it.\
    </li>\
    <li>\
      Open <em>~/.ssh/id_rsa.pub</em> and copy & paste the contents into<br>\
      the box below, then click on "Add".<br>\
      Note that <em>id_rsa.pub</em> is your public key and can be shared,<br>\
      while <em>id_rsa</em> is your private key and should be kept secret.\
    </li>\
  <\ol>
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
watchedProjectColumnNewPatchSets = New Patch Sets
watchedProjectColumnAllComments = All Comments
watchedProjectColumnSubmittedChanges = Submitted Changes
watchedProjectColumnAbandonedChanges = Abandoned 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>
errorDialogTitleRegisterNewEmail = Email Registration Failed


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
