mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-16 22:51:17 +07:00
1639 lines
102 KiB
Properties
1639 lines
102 KiB
Properties
git4idea.vcs.name=Git
|
|
git4idea.vcs.name.with.mnemonic=_Git
|
|
|
|
abort=Abort
|
|
abort.operation.progress.title=Aborting {0} Process
|
|
abort.operation.dialog.title=Abort {0}
|
|
abort.operation.dialog.msg=Abort {0}{1}?
|
|
abort.operation.failed={0} abort failed
|
|
abort.operation.succeeded={0} abort succeeded
|
|
abort.operation.merge.name=merge
|
|
abort.operation.cherry.pick.name=cherry-pick
|
|
abort.operation.revert.name=revert
|
|
abort.operation.rebase.name=rebase
|
|
abort.operation.indicator.text=git {0} --abort{1}
|
|
|
|
add.adding=Adding files\u2026
|
|
|
|
annotate.cannot.annotate.dir=Cannot annotate directory
|
|
annotate.output.lack.data=Output for line {0} lacks the necessary data
|
|
annotate.line.mismatch.exception=Adding info for line {0}, but we are expecting it to be for line {1}
|
|
|
|
apply.changes.operation.successful={0} successful
|
|
apply.changes.nothing.to.do=Nothing to {0}
|
|
apply.changes.unresolved.conflicts.text=There are unresolved conflicts in the working tree.
|
|
apply.changes.unresolved.conflicts.notification.resolve.action.text=Resolve\u2026
|
|
apply.changes.unresolved.conflicts.notification.abort.action.text=Abort {0}
|
|
apply.changes.resolving.conflicts.progress.title=Resolving conflicts\u2026
|
|
apply.changes.applied.for.commits={0} {1,choice,1#commit|2#{1,number} commits} from {2}
|
|
apply.changes.operation.canceled={0} canceled
|
|
apply.changes.operation.failed={0} failed
|
|
apply.changes.operation.performed.with.conflicts={0} was performed with conflicts
|
|
apply.changes.operation.successful.for.commits=However, {0} succeeded for the following {1,choice,1#commit|2#commits}:
|
|
apply.changes.restore.notification.description=Local changes were saved before {0}
|
|
apply.changes.restore.notification.title=Restore local changes
|
|
apply.changes.save.and.retry.operation={0} Changes and Retry
|
|
apply.changes.skipped={0} {1,choice,1#was|2#were} skipped, because all changes have already been {2}.
|
|
apply.changes.everything.applied=All changes from {0} have already been {1}
|
|
|
|
apply.conflict.dialog.description.label.text=Conflicts during {0} of commit {1} made by {2}{3}
|
|
|
|
blob.not.found=Blob not found: {0} - {1}
|
|
|
|
changes.retrieving=Retrieving Changes for Revision {0}
|
|
|
|
commit.action.commit.and.rebase.text=Commit and Rebase\u2026
|
|
commit.action.name=Comm&it
|
|
commit.author.diffs=<html>Author differs from default</html>
|
|
commit.author=A&uthor:
|
|
common.current.branch.tooltip=The currently checked-out branch.
|
|
common.current.branch=Current Branch:
|
|
common.git.root.tooltip=Select Git VCS root
|
|
common.git.root=Git &Root:
|
|
common.no.active.branch=<no active branch>
|
|
common.refreshing=Refreshing files
|
|
common.suffix.in.one.repository=in {0}
|
|
common.suffix.in.several.repositories=in {0} repositories
|
|
|
|
conflict.resolver.unmerged.files.check.error.notification.description.text=Cannot check the working tree for unmerged files because of an error. {0}
|
|
|
|
login.dialog.label.login.to.url=Log In to {0}
|
|
login.dialog.button.login=Log In
|
|
login.dialog.prompt.enter.credentials=Enter credentials:
|
|
login.dialog.select.login.way.credentials=Enter credentials
|
|
login.dialog.select.login.way.use.helper=Use credentials helper
|
|
login.dialog.username.label=Username:
|
|
login.dialog.password.label=Password:
|
|
login.dialog.error.username.cant.be.empty=Username cannot be empty
|
|
login.dialog.error.password.cant.be.empty=Password cannot be empty
|
|
login.dialog.login.with.selected.provider=Log In with {0}\u2026
|
|
|
|
stats.wrong.git.shortlog.response=Unexpected line ''{0}'' in git shortlog output
|
|
|
|
computing.annotation=Computing annotation for {0}
|
|
diff.find.error=Finding revision for diff: {0}
|
|
error.dialog.title=Error
|
|
error.list.title={0} Error:
|
|
error.occurred.during=Error Occurred During ''{0}''
|
|
errors.message.item=\n {0}
|
|
errors.message=The Git operation ended with multiple errors:{0}
|
|
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
fetch.action.name=Fetch
|
|
fetch.pruned.obsolete.remote.references=Pruned obsolete remote {0,choice,1#reference|2#references}: {1}
|
|
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
find.git.error.title=Error Running Git
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
find.git.success.title=Git executed successfully
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
find.git.unsupported.message=<html><tt>{0}</tt><br>This version is unsupported, and some plugin functionality could fail to work.<br>The minimal supported version is <em>{1}</em>.</html>
|
|
|
|
local.changes.freeze.message.git.operation.prefix=Git {0}
|
|
git.error.exit=The Git process exited with the code {0}
|
|
git.running=Running: {0}
|
|
|
|
init.destination.directory.description=Select directory where the new Git repository will be created.
|
|
init.destination.directory.title=Create Git Repository
|
|
init.warning.already.under.git=The selected directory <tt>{0}</tt> is already under Git.\n\
|
|
Are you sure that you want to create a new VCS root?
|
|
init.warning.title=Git Init
|
|
initializing.title=Initializing repository\u2026
|
|
|
|
mention.in=\u0020in {0}
|
|
|
|
merge.action.name=Merge
|
|
merge.action.operation.failed=Git {0} failed
|
|
merge.action.before.update.label=Before update
|
|
merge.action.after.update.label=After update
|
|
merge.branch.title=Merge Changes
|
|
merge.branch.into.current.title=Merge into {0}
|
|
merge.branch.loading.branches.progress=Loading unmerged branches\u2026
|
|
merge.no.branch.selected.error=The merge branch should be selected.
|
|
merge.no.matching.branch.error=There is no matching branch.
|
|
merge.branch.already.merged=Branch ''{0}'' is already merged
|
|
merge.commit.message.label=Commit message:
|
|
merge.options.modify=Modify options
|
|
merge.options.modify.popup.title=Add Merge Options
|
|
merge.option.no.ff=Create a merge commit even if it can be fast-forwarded
|
|
merge.option.ff.only=Merge only if it can be fast-forwarded
|
|
merge.option.squash=Create a single commit for all merged changes
|
|
merge.option.msg=Specify a message for the merge commit
|
|
merge.option.no.commit=Do not commit the merge result
|
|
merge.option.no.verify=Bypass the pre-merge and commit message hooks
|
|
merge.option.allow.unrelated.histories=Allow merging histories that do not share a common ancestor.
|
|
merge.branch.popup.empty.text=No branches
|
|
merge.branch.field.placeholder=Specify branch
|
|
merge.tool.column.status.deleted=Deleted
|
|
merge.tool.column.status.modified=Modified
|
|
merge.tool.column.theirs.status=Theirs
|
|
merge.tool.column.theirs.with.branch.status=Theirs ({0})
|
|
merge.tool.column.yours.status=Yours
|
|
merge.tool.column.yours.with.branch.status=Yours ({0})
|
|
merging.title=Merging changes to {0}
|
|
paths.affected.title=Paths affected in commit {0}
|
|
pull.action.name=Pull
|
|
pull.button=Pull
|
|
pulling.title=Pulling changes from {0}
|
|
pull.branch.not.selected.error=The branch to pull from should be selected.
|
|
pull.branch.nothing.to.pull=No branches
|
|
pull.branch.no.matching.remotes=No remotes
|
|
pull.branch.field.placeholder=Specify branch
|
|
pull.fetch.failed.notification.title=Cannot load remote branches
|
|
pull.fetch.failed.notification.text=Select a local and a remote repository
|
|
pull.remote.not.selected=Select the remote to pull from
|
|
pull.repository.not.selected.error=Select a repository
|
|
pull.options.modify.popup.title=Add Pull Options
|
|
pull.option.ff.only=Merge only if it can be fast-forwarded
|
|
pull.option.no.ff=Create a merge commit even if it can be fast-forwarded
|
|
pull.option.squash.commit=Create a single commit for all pulled changes
|
|
pull.option.no.commit=Merge, but do not commit the result
|
|
pull.option.rebase=Rebase incoming changes on top of the current branch
|
|
|
|
pull.dialog.title=Pull
|
|
pull.dialog.with.branch.title=Pull to {0}
|
|
pull.dialog.fetch.shortcuts.hint=Press {0} to update branches
|
|
|
|
operation.action.message=Multiple Git roots have unfinished {0} process, please select root to perform action on.
|
|
|
|
rebase.abort.and.rollback.dialog.message=Abort rebase in {0} only or also rollback rebase in {1}?
|
|
rebase.abort.and.rollback.dialog.no.button.text=Abort Only
|
|
rebase.abort.and.rollback.dialog.yes.button.text=Abort and Rollback
|
|
rebase.abort.dialog.message=Abort rebase in {0}?
|
|
rebase.abort.dialog.ok.button.text=Abort
|
|
rebase.abort.dialog.title=Abort Rebase
|
|
rebase.abort.notification.failed.title=Abort rebase failed
|
|
rebase.abort.notification.successful.message=Abort rebase succeeded
|
|
rebase.abort.notification.warning.rollback.failed.message=Rollback failed in {0}:{1}{2}
|
|
rebase.abort.notification.warning.rollback.failed.title=Rebase rollback failed
|
|
rebase.abort.notification.warning.rollback.failed.with.repo.message=Abort rebase was successful in {0}, but rollback failed in {1}:{2}{3}
|
|
rebase.abort.progress.indicator.command.in.repo.title={0} in {1}
|
|
rebase.abort.rollback.successful.rebase.dialog.message=Do you want to rollback the successful rebase in {0}?
|
|
rebase.abort.rollback.successful.rebase.dialog.ok.button.text=Rollback
|
|
rebase.confirmation.dialog.published.commits.button.cancel.text=Cancel
|
|
rebase.confirmation.dialog.published.commits.button.rebase.text=Rebase Anyway
|
|
rebase.confirmation.dialog.published.commits.message.first=You are trying to rebase some commits already pushed to a protected branch.
|
|
rebase.confirmation.dialog.published.commits.message.second=Rebasing them would duplicate commits, which is not recommended and most likely unwanted.
|
|
rebase.confirmation.dialog.published.commits.title=Rebasing Published Commit
|
|
rebase.conflict.diff.dialog.left.title=Rebasing {0} from {1}
|
|
rebase.conflict.diff.dialog.right.simple.title=Already rebased commits
|
|
rebase.conflict.diff.dialog.right.with.branch.title=Already rebased commits and commits from {0}
|
|
rebase.couldnt.resolve.file=Could not resolve {0}
|
|
rebase.dialog.error.upstream.not.selected=Select an upstream
|
|
rebase.dialog.error.base.not.selected=Select a new base
|
|
rebase.dialog.error.branch.or.tag.not.exist=There is no such branch or tag
|
|
rebase.dialog.error.branch.not.selected=Select a branch to switch to
|
|
rebase.dialog.error.branch.invalid=Branch ''{0}'' does not exist
|
|
rebase.dialog.error.rebase.in.progress=Interactive rebase is already in progress for this Git root
|
|
rebase.dialog.root.invalid.label.text=(invalid)
|
|
rebase.dialog.progress.loading.tags=Loading tags\u2026
|
|
rebase.dialog.help=Show Git rebase help
|
|
rebase.dialog.start.rebase=Rebase
|
|
rebase.dialog.title=Rebase
|
|
rebase.dialog.target=branch or hash
|
|
rebase.dialog.new.base=new base (branch or hash)
|
|
rebase.dialog.old.base=old base (branch or hash)
|
|
rebase.dialog.branch.field=source branch
|
|
rebase.options.modify.dialog.title=Add Rebase Options
|
|
rebase.option.onto=Specify a new base for the rebased commits
|
|
rebase.option.interactive=Edit commits before rebasing
|
|
rebase.option.update.refs=Auto-update branches pointing to rebased commits
|
|
rebase.option.rebase.merges=Recreate commits topology
|
|
rebase.option.switch.to.branch=Select another branch to rebase
|
|
rebase.option.keep.empty=Do not remove empty commits during rebase
|
|
rebase.option.root=Rebase all commits in the branch
|
|
rebase.help.popup.ad.text=Press Space to open external link
|
|
rebase.help.rebase.branch=Rebase a branch based on one branch to another:
|
|
rebase.help.link=git rebase on git-scm.com
|
|
rebase.entry.action.name.drop=Drop
|
|
rebase.entry.action.name.edit=Edit
|
|
rebase.entry.action.name.fixup=Fixup
|
|
rebase.entry.action.name.update.ref=Update Ref
|
|
rebase.entry.action.name.pick=Pick
|
|
rebase.entry.action.name.reword=Reword
|
|
rebase.entry.action.name.squash=Squash
|
|
rebase.entry.action.name.unknown=Unknown
|
|
rebase.git.operation.name=Rebase
|
|
rebase.interactive.dialog.discard.modifications.cancel=Cancel Rebase
|
|
rebase.interactive.dialog.discard.modifications.continue=Continue Rebasing
|
|
rebase.interactive.dialog.discard.modifications.discard=Discard
|
|
rebase.interactive.dialog.discard.modifications.message=Discard changes and cancel rebase?
|
|
rebase.interactive.dialog.git.commands.column.action=Action
|
|
rebase.interactive.dialog.git.commands.column.hash=Hash
|
|
rebase.interactive.dialog.git.commands.column.subject=Subject
|
|
rebase.interactive.dialog.git.commands=Git Commands
|
|
rebase.interactive.dialog.reset.link.text=Reset
|
|
rebase.interactive.dialog.reword.hint.text=Press {0} to apply changes
|
|
rebase.interactive.dialog.start.rebase=Start Rebasing
|
|
rebase.interactive.dialog.stop.to.edit.text=Stop to Edit
|
|
rebase.interactive.dialog.title=Rebasing Commits
|
|
rebase.interactive.dialog.view.git.commands.text=View Git Commands
|
|
rebase.interactive.dialog.cancel.reword.warning.title=Cancel Reword
|
|
rebase.interactive.dialog.cancel.reword.warning.body=Entered commit message will be lost
|
|
rebase.interactive.dialog.cancel.reword.warning.cancel=Cancel Reword
|
|
rebase.interactive.dialog.cancel.reword.warning.continue=Keep Editing
|
|
rebase.interactive.edit.commit.message.dialog.title=Git Commit Message
|
|
rebase.interactive.edit.commit.message.ok.action.title=Continue Rebasing
|
|
rebase.interactive.noop.dialog.text=There are no commits to rebase because the current branch is directly below the base branch, or they point to the same commit (the 'noop' situation).\n Do you want to continue (this will reset the current branch to the base branch)?
|
|
rebase.interactive.noop.dialog.title=Git Rebase
|
|
rebase.interactive.unstructured.editor.dialog.root.label=Git Root: {0}
|
|
rebase.log.action.operation.rebase.name=rebase
|
|
rebase.log.action.operation.reword.name=reword
|
|
rebase.log.commit.editing.action.commit.not.in.head.error.text=The commit is not in the current branch
|
|
rebase.log.commit.editing.action.commit.pushed.to.protected.branch.error.text=The commit is already pushed to protected branch ''{0}''
|
|
rebase.log.commit.editing.action.disabled.parents.description=Selected commit has {0} parents
|
|
rebase.log.multiple.commit.editing.action.disabled.external.repository.description=Selected {0,choice,1#commit|2#commits} {0,choice,1#is|2#are} from external repository
|
|
rebase.log.multiple.commit.editing.action.disabled.multiple.repository.description=Selected {0,choice,1#commit|2#commits} {0,choice,1#is|2#are} from different repositories
|
|
rebase.log.commit.editing.action.progress.containing.branches.title=Searching for branches containing the selected commit\u2026
|
|
rebase.log.commit.editing.action.prohibit.state.grafting=Cannot {0} during cherry-pick
|
|
rebase.log.commit.editing.action.prohibit.state.merging=Cannot {0} during merge
|
|
rebase.log.commit.editing.action.prohibit.state.rebasing=Cannot {0} during rebase
|
|
rebase.log.commit.editing.action.prohibit.state.reverting=Cannot {0} during revert
|
|
rebase.log.commit.editing.action.prohibit.state=Cannot {0}
|
|
rebase.log.undo.impossible.pushed.to.protected.branch.notification.text=Commits from current branch have already been pushed to protected branch {0}
|
|
rebase.log.drop.action.confirmation.title=Drop {0,choice,1#Commit|2#Commits}
|
|
rebase.log.drop.action.confirmation.message=Do you want to drop {0} {0,choice,1#commit|2#commits}?
|
|
rebase.log.drop.action.custom.text=Drop {0,choice,1#Commit|2#Commits}
|
|
rebase.log.drop.action.failure.title=Could not Drop Commits
|
|
rebase.log.drop.progress.indicator.title=Dropping {0,choice,1#commit|2#commits}\u2026
|
|
rebase.log.drop.success.notification.title=Dropped {0} {0,choice,1#commit|2#commits}
|
|
rebase.log.drop.undo.failed.title=Undo drop failed
|
|
rebase.log.drop.undo.impossible.title=Cannot undo drop
|
|
rebase.log.drop.undo.progress.title=Undoing drop\u2026
|
|
rebase.log.multiple.commit.editing.action.cant.find.head=Could not find HEAD branch in repository which contains selected {0,choice,1#commit|2#commits}
|
|
rebase.log.multiple.commit.editing.action.progress.indicator.action.possibility.check=Checking if it is allowed to edit selected commits\u2026
|
|
rebase.log.multiple.commit.editing.action.specific.commit.not.in.head=Commit {0} is not in the current branch
|
|
rebase.log.multiple.commit.editing.action.specific.commit.root.or.merge=Commit {0} has {1} parents
|
|
rebase.log.create.fixup.commit.action.failure.title=Cannot Create Fixup Commit
|
|
rebase.log.create.squash.commit.action.failure.title=Cannot Create Squash Commit
|
|
rebase.log.interactive.action.failure.title=Cannot Start Rebase
|
|
rebase.log.reword.action.failure.title=Could not Edit Commit Message
|
|
rebase.log.action.loading.commit.message.failed.message=Could not load changes of {0,choice,1#commit|2#commits}
|
|
rebase.log.reword.action.notification.successful.title=Commit Message Changed
|
|
rebase.log.reword.action.notification.undo.failed.title=Undo Commit Message Edit Failed
|
|
rebase.log.reword.action.notification.undo.not.allowed.repository.changed.message=Repository has already been changed
|
|
rebase.log.reword.action.notification.undo.not.allowed.title=Cannot Undo Commit Message Edit
|
|
rebase.log.action.progress.indicator.loading.commit.message.title=Loading {0,choice,1#commit|2#commits} details\u2026
|
|
rebase.log.squash.action.failure.title=Could not Squash Commits
|
|
rebase.log.squash.new.message.dialog.label=Edit message for squashed commit
|
|
rebase.log.squash.new.message.dialog.title=Squashed Commit Message
|
|
rebase.log.squash.progress.indicator.title=Squashing\u2026
|
|
rebase.log.squash.success.notification.title=Commits Squashed
|
|
rebase.log.squash.undo.failed.title=Undo Squash Failed
|
|
rebase.log.squash.undo.impossible.title=Cannot Undo Squash
|
|
rebase.log.squash.undo.progress.title=Undoing squash\u2026
|
|
rebase.log.reword.action.progress.indicator.title=Rewording\u2026
|
|
rebase.log.reword.action.progress.indicator.undo.title=Undoing reword\u2026
|
|
rebase.log.reword.dialog.description.label=Edit message for commit {0} by {1}
|
|
rebase.log.reword.dialog.failed.pushed.to.protected.message=Cannot edit selected {0,choice,1#commit|2#commits}: commit {1} was pushed to protected branch ''{2}''
|
|
rebase.log.reword.dialog.failed.repository.changed.message=Cannot edit selected {0,choice,1#commit|2#commits}: repository state was changed
|
|
rebase.log.reword.dialog.title=Edit Commit Message
|
|
rebase.notification.action.abort.text=Abort
|
|
rebase.notification.action.continue.text=Continue
|
|
rebase.notification.action.retry.text=Retry
|
|
rebase.notification.action.view.shelf.text=View Shelf\u2026
|
|
rebase.notification.action.view.stash.text=View Stash\u2026
|
|
rebase.notification.conflict.title=Rebase stopped due to conflicts
|
|
rebase.notification.editing.title=Rebase stopped for editing
|
|
rebase.notification.failed.continue.title=Continue rebase failed
|
|
rebase.notification.failed.rebase.title=Rebase failed
|
|
save.notification.failed.shelf.text=Could not shelve local uncommitted changes:
|
|
save.notification.failed.stash.text=Could not stash local uncommitted changes:
|
|
rebase.notification.no.rebase.in.progress.abort.title=Cannot abort rebase
|
|
rebase.notification.no.rebase.in.progress.continue.title=Cannot continue rebase
|
|
rebase.notification.no.rebase.in.progress.message=No rebase in progress
|
|
rebase.notification.not.allowed.empty.repository.message=Repository {0} is empty.
|
|
rebase.notification.not.allowed.grafting.message.first=There is an unfinished cherry-pick process in {0}.
|
|
rebase.notification.not.allowed.grafting.message.second=You should finish it before starting a rebase.
|
|
rebase.notification.not.allowed.merging.message.first=There is an unfinished merge process in {0}.
|
|
rebase.notification.not.allowed.merging.message.second=You should complete the merge before starting a rebase.
|
|
rebase.notification.not.allowed.message=Rebase is not possible in {0}.
|
|
rebase.notification.not.allowed.rebasing.message.first=There is an unfinished rebase process in {0}.
|
|
rebase.notification.not.allowed.rebasing.message.second=You should complete it before starting another rebase.
|
|
rebase.notification.not.allowed.reverting.message.first=There is an unfinished revert process in {0}.
|
|
rebase.notification.not.allowed.reverting.message.second=You should finish it before starting a rebase.
|
|
rebase.notification.not.allowed.title=Rebase not allowed
|
|
rebase.notification.not.started.title=Rebase not started
|
|
rebase.notification.saved.local.changes.part.shelf.text=Local changes were shelved before rebase.
|
|
rebase.notification.saved.local.changes.part.stash.text=Local changes were stashed before rebase.
|
|
rebase.notification.successful.rebased.checkout.message=Checked out{0,choice,0#|1# {1}} and rebased it{2,choice,0#|1# on {3}}
|
|
rebase.notification.successful.rebased.message=Rebased{0,choice,0#|1# {1}}{2,choice,0#|1# on {3}}
|
|
rebase.notification.successful.title=Rebase successful
|
|
rebase.notification.all.conflicts.resolved.title=Resolve Conflicts
|
|
rebase.notification.all.conflicts.resolved.text=All conflicts have been resolved. Do you want to continue rebase?
|
|
rebase.notification.all.conflicts.resolved.continue.rebase.action.text=Con&tinue Rebase
|
|
rebase.progress.indicator.aborting.title=Aborting rebase process\u2026
|
|
rebase.progress.indicator.conflicts.collecting.title=Collecting conflicts to resolve\u2026
|
|
rebase.progress.indicator.continue.title=Continuing rebase process\u2026
|
|
rebase.progress.indicator.preparing.title=Preparing to rebase\u2026
|
|
rebase.progress.indicator.retry.title=Retrying rebase process\u2026
|
|
rebase.progress.indicator.title=Rebasing\u2026
|
|
rebase.simple.editor.dialog.title=Git Editor
|
|
rebase.update.project.abort.task.title=Aborting rebase\u2026
|
|
rebase.update.project.conflict.error.notification.description=Then you may <b>continue rebase</b>. <br/> You also may <b>abort rebase</b> to restore the original branch and stop rebasing.
|
|
rebase.update.project.conflict.error.notification.title=Cannot continue rebase
|
|
rebase.update.project.conflict.merge.description.label=Merge conflicts detected. Resolve them before continuing rebase.
|
|
rebase.update.project.notification.abort.error.message=Error aborting rebase
|
|
rebase.update.project.notification.abort.success.message=Rebase aborted
|
|
rebase.update.project.notification.failed.message=Could not proceed with rebase. {0}
|
|
rebase.update.project.notification.failed.title=Rebase Error
|
|
rebase.using.log.couldnt.start.error=Cannot perform the rebase because the IDE generated an invalid 'git-rebase-todo' file. Do you want to retry the rebase using Git native file generation?
|
|
merge.update.project.generic.error.title=Cannot complete update
|
|
merge.update.project.conflict.merge.description.label=Merge conflicts detected. Resolve them before continuing update.
|
|
|
|
remove.removing=Removing files\u2026
|
|
repository.action.missing.roots.misconfigured=None of configured Git roots are under Git. The configured directory must have ".git" directory in it.
|
|
repository.action.missing.roots.title=No Git Roots
|
|
repository.action.missing.roots.unconfigured.message=No Git roots are configured for the project.
|
|
repository.not.found.error=Cannot find configured Git repository for {0}
|
|
reset.action.name=Reset Head\u2026
|
|
reset.commit.invalid=The specified commit expression did not pass validation.
|
|
reset.commit.label=To &Commit:
|
|
reset.commit.tooltip=The commit that will become the current HEAD\n as result of reset operation.
|
|
reset.title=Reset Head
|
|
reset.type.tooltip=<html>The reset type (see also <code>git reset</code> man page):<ul><li><b>Mixed</b> resets index but not working tree</li><li><b>Soft</b> leaves index and working tree, just moves head pointer</li><li><b>Hard</b> resets index and working tree.<em>Changes in the working tree will be lost</em></li></ul></html>
|
|
reset.type=Reset &Type:
|
|
reset.validate=&Validate
|
|
resetting.title=Resetting HEAD\u2026
|
|
restore.conflict.dialog.description.label.text=Uncommitted changes that were saved before {0} have conflicts with files from {1}
|
|
restore.conflict.diff.dialog.left.shelf.title=Uncommitted changes from the shelf
|
|
restore.conflict.diff.dialog.left.stash.title=Uncommitted changes from the stash
|
|
restore.conflict.diff.dialog.right.title=Changes from {0}
|
|
preserving.process.local.changes.not.restored.error.title=Local changes were not restored
|
|
restore.notification.failed.shelf.message=Before {0} your uncommitted changes were saved to shelf.
|
|
restore.notification.failed.stash.message=Before {0} your uncommitted changes were saved to stash.
|
|
restore.notification.failed.title=Local changes were not restored
|
|
restore.notification.failed.show.changes.action=View saved changes\u2026
|
|
|
|
revision.load.contents=Load Revision Contents
|
|
|
|
reference.validating.progress.indicator.title=Validating revision\u2026
|
|
|
|
save.load.conflict.dialog.diff.left.title=Your uncommitted changes
|
|
save.load.conflict.dialog.diff.right.title=Changes from remote
|
|
save.notification.failed.title=Could not save uncommitted changes on {0}
|
|
|
|
smart.operation.dialog.north.panel.label.shelf.text=<html>Your local changes to the following files would be overwritten by {0}.<br/> {1} can shelve the changes, {0} and unshelve them after that.</html>
|
|
smart.operation.dialog.north.panel.label.stash.text=<html>Your local changes to the following files would be overwritten by {0}.<br/> {1} can stash the changes, {0} and unstash them after that.</html>
|
|
smart.operation.dialog.ok.action.shelf.description=Shelve local changes, {0}, unshelve
|
|
smart.operation.dialog.ok.action.stash.description=Stash local changes, {0}, unstash
|
|
smart.operation.dialog.operation.name.and.overwrite.local.changes={0} and overwrite local changes
|
|
smart.operation.dialog.git.operation.name.problem=Git {0} Problem
|
|
smart.operation.dialog.smart.operation.name=Smart {0}
|
|
smart.operation.dialog.don.t.operation.name=Don''t {0}
|
|
|
|
|
|
stash.action.name=Stash
|
|
stash.button=Create Stash
|
|
stash.error.can.not.stash.changes.now=Cannot Stash Changes Now
|
|
stash.keep.index.tooltip=If this checkbox is selected, all changes already added to the index are left intact
|
|
stash.keep.index=Keep &index
|
|
stash.message.tooltip=Enter stash message here
|
|
stash.message=&Message:
|
|
stash.progress.indicator.title=Stashing changes from ''{0}''\u2026
|
|
stash.title=Stash
|
|
stash.unstash.conflict.dialog.description.label.text=Uncommitted changes that were stashed before update have conflicts with updated files.
|
|
stash.unstash.progress.indicator.title=Popping changes to ''{0}''\u2026
|
|
stash.unstash.unresolved.conflict.warning.notification.message=Your uncommitted changes were saved to stash.<br/>Unstash is not complete, you have unresolved merges in your working tree<br/>Resolve conflicts and drop the stash.
|
|
stash.unstash.unresolved.conflict.warning.notification.show.stash.action=View saved changes\u2026
|
|
stash.unstash.unresolved.conflict.warning.notification.resolve.conflicts.action=Resolve conflicts\u2026
|
|
stash.unstash.unresolved.conflict.warning.notification.title=Local changes were restored with conflicts
|
|
stash.error=Failed to stash {0}
|
|
# suppress inspection "UnusedProperty" - used in third-party plugins
|
|
stashing.title=Stashing Changes\u2026
|
|
stashing.progress.title=Stashing changes\u2026
|
|
stash.editor.diff.preview.id.change.title={0}: {1}
|
|
stash.editor.diff.preview.empty.title=Stash
|
|
stashes.and.shelves.tab.name=Stashes and Shelves
|
|
stash.tab.name=Stash
|
|
stash.root.node.title=Stashes
|
|
stash.empty.text.help.link=Getting started with Stash and Shelf
|
|
|
|
action.Git.Stash.Pop.text=&Pop
|
|
action.Git.Stash.Pop.description=Pop selected stash
|
|
action.Git.Stash.Apply.text=&Apply
|
|
action.Git.Stash.Apply.description=Apply selected stash
|
|
action.Git.Stash.UnstashAs.text=&Unstash\u2026
|
|
action.Git.Stash.UnstashAs.description=Pop or apply selected stash as new branch with or without index
|
|
action.Git.Stash.Drop.text=&Drop
|
|
action.Git.Stash.Drop.description=Drop selected stash
|
|
action.Git.Stash.Clear.text=&Clear
|
|
action.Git.Stash.Clear.description=Clear all stashes
|
|
action.Git.Stash.Clear.in.root.text=&Clear Stashes in {0}
|
|
action.Git.Stash.Clear.in.root.description=Clear all stashes in the selected root
|
|
action.Git.Show.Stash.text=Show Git Stash
|
|
action.Git.Show.Stash.description=Open the Git Stash tab
|
|
action.Git.Show.Stash.With.Shelf.text=Show Stashes and Shelves
|
|
action.Git.Show.Stash.With.Shelf.description=Open the Stashes and Shelves tab
|
|
action.Git.Stash.Refresh.text=Refresh Stashes
|
|
action.Git.Stash.Refresh.description=Refresh the List of Stashes
|
|
action.Git.Stash.Toggle.Split.Preview.text=Preview Diff
|
|
|
|
stash.unstash.changes.in.root.dialog.title=Unstash Changes in {0}
|
|
stash.unstash.changes.current.branch.label=Current branch:
|
|
|
|
stash.files.action.text=Stash Files
|
|
stash.files.progress.title=Stashing Files
|
|
stash.files.error.message=Failed to Stash Files
|
|
stash.files.success=Files stashed successfully
|
|
stash.files.in.roots.success=Files in {0} stashed successfully
|
|
stash.view.stashes.link=View Git stashes
|
|
stash.enable.stashes.link=Enable and view Git stashes
|
|
|
|
stash.changes.non.empty.index.for.roots.notification.text=Staging area in {0} contains modifications to other files that were saved to the stash
|
|
stash.changes.non.empty.index.notification.action=Don't show again
|
|
|
|
unstash.action.name=Unstash
|
|
unstash.branch.label=As new &branch:
|
|
unstash.branch.tooltip=If non-empty name is entered, the stash is checked out as a new branch
|
|
unstash.button.apply=Apply Stash
|
|
unstash.button.branch=Branch
|
|
unstash.button.pop=Pop Stash
|
|
unstash.clear.tooltip=Delete all stashes in the repository
|
|
unstash.clear=&Clear
|
|
unstash.clearing.stashes=Clearing stashes\u2026
|
|
unstash.drop.tooltip=Delete selected stash
|
|
unstash.drop=&Drop
|
|
unstash.conflict.dialog.description.label.text=Conflicts during unstashing {0}
|
|
unstash.conflict.diff.dialog.left.title=Local changes
|
|
unstash.conflict.diff.dialog.right.title=Changes from stash
|
|
unstash.dialog.remove.stash.progress.indicator.title=Removing Stash {0}\u2026
|
|
unstash.dialog.show.stashes.error.dialog.title=Could not Show the List of Stashes
|
|
unstash.dialog.stash.list.load.progress.indicator.title=Loading list of stashes\u2026
|
|
unstash.dialog.unresolved.conflict.warning.notification.message=Unstash is not complete, you have unresolved merges in your working tree.
|
|
unstash.dialog.unresolved.conflict.warning.resolve.conflicts.action=Resolve conflicts\u2026
|
|
unstash.dialog.unresolved.conflict.warning.notification.title=Conflicts were not resolved during unstash
|
|
unstash.pop.stash.tooltip=If selected the stash is dropped after it is applied
|
|
unstash.pop.stash=&Pop stash
|
|
unstash.reinstate.index.tooltip=Attempt to reinstate index as well as working tree changes
|
|
unstash.reinstate.index=Reinstate &index
|
|
unstash.stashes=&Stashes:
|
|
unstash.title=Unstash Changes
|
|
unstash.unstashing=Unstashing\u2026
|
|
unstash.view.tooltip=View selected stash
|
|
unstash.view=&View
|
|
unstash.view.dialog.title=Paths Affected by {0}
|
|
unstash.error.can.not.unstash.changes.now=Cannot Unstash Changes Now
|
|
unstash.unstashed.with.conflicts.error.title=Unstashed with conflicts
|
|
unstash.stash.applied=Stash successfully applied
|
|
stash.load.changes.error=Could not load changes in root {0} in stash resolved to {1}
|
|
|
|
unstash.clear.confirmation.message=Remove all stashes? This cannot be undone.
|
|
unstash.clear.confirmation.title=Remove All Stashes?
|
|
unstash.drop.confirmation.message=<html>Do you want to remove {0}?<br/>"{1}"</html>
|
|
unstash.drop.confirmation.title=Remove Stash {0}?
|
|
|
|
unshallow.repository.notification.message=Shallow repository detected
|
|
unshallow.repository.notification.title=This repository can be converted to a complete one
|
|
|
|
notification.title.unstash.failed=Unstash failed
|
|
notification.title.unstash.failed.index.conflict=Unstash failed due to an index conflict
|
|
exception.message.could.not.stash.root.error=Cannot stash {0}: {1}
|
|
|
|
tag.action.name=Tag
|
|
tag.button=Create Tag
|
|
tag.commit.label=&Commit:
|
|
tag.commit.tooltip=Enter name of commit or object to tag or leave blank to use HEAD.
|
|
tag.error.creating.message.file.message=Unable to create message file: {0}
|
|
tag.error.invalid.commit=The commit or object name is invalid.
|
|
tag.error.tag.exists=The tag with the same name exists.
|
|
tag.force.tooltip=Force creation of the tag even if another tag with such name already exists.
|
|
tag.force=&Force
|
|
tag.getting.existing.tags=Getting Existing Tags\u2026
|
|
tag.message.label=&Message:
|
|
tag.message.tooltip=If the message is not empty, an annotated tag is created.
|
|
tag.name.label=Tag &Name:
|
|
tag.name.tooltip=Enter the new tag name here.
|
|
tag.title=Tag
|
|
tag.validate.tooltip=Click this button to validate the commit to be tagged
|
|
tag.validate=&Validate
|
|
tag.progress.title=Tagging\u2026
|
|
|
|
update.options.display.name=Git Update Settings
|
|
update.notification.update.error=Cannot update
|
|
update.notification.choose.upstream.branch=Choose upstream branch
|
|
update.skip.root.reason.no.tracked.branch=no tracked branch
|
|
update.skip.root.reason.detached.head=detached HEAD
|
|
|
|
util.remote.renderer.none=None
|
|
vfs.listener.add.single.prompt=Do you want to add the following file to Git?\n{0}\n\nIf you choose Cancel, you can still add it later manually.
|
|
vfs.listener.add.single.title=Add File to Git
|
|
vfs.listener.add.title=Add Files to Git
|
|
vfs.listener.checking.ignored=Checking for ignored files\u2026
|
|
vfs.listener.delete.single.prompt=Do you want to delete the following file from Git?\n{0}\n\nIf you choose Cancel, you can still delete it later manually.
|
|
vfs.listener.delete.single.title=Delete File from Git
|
|
vfs.listener.delete.title=Delete Files from Git
|
|
notification.ignore.file.generation.error.text.files.progress.title=Could not generate .gitignore file
|
|
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
git.commit.message.empty.title=Commit Message Is Empty
|
|
git.commit.nothing.to.commit.error.message=Nothing to commit
|
|
|
|
git.executable.detect.progress.title=Detecting Git Executable
|
|
git.executable.version.progress.title=Identifying Git Version
|
|
git.executable.version.is=Git version is {0}
|
|
git.executable.error.file.not.found=No such file: {0}
|
|
git.executable.error.bash.not.found=Cannot find bash executable
|
|
git.executable.new.version.update.available=Update to Git {0}
|
|
|
|
git.executable.validation.error.start.title=Cannot Run Git
|
|
git.executable.validation.error.version.title=Unsupported Git Version {0}
|
|
git.executable.validation.error.version.message=At least {0} is required
|
|
git.executable.validation.error.wsl1.unsupported.message=WSL version 1 is not supported, see <a href='https://youtrack.jetbrains.com/issue/IDEA-242469'>IDEA-242469</a>
|
|
git.executable.validation.error.xcode.title=Accept XCode/iOS License to Run Git
|
|
git.executable.validation.error.xcode.message=Run \u201Csudo xcodebuild -license\u201D and retry (admin rights required)
|
|
git.executable.validation.cant.identify.executable.message=Cannot identify version of Git executable {0}
|
|
git.executable.validation.error.no.response.in.n.attempts.message=Cannot identify version of Git executable: no response{0,choice,0#|2# in {0} attempts}
|
|
git.executable.validation.cant.run.in.safe.mode=Cannot run a Git command in the safe mode
|
|
git.executable.unknown.error.message=Failed to start Git process: {0}
|
|
git.error.cant.process.output=Failed to process Git output: {0}
|
|
|
|
git.executable.notification.title=Cannot start Git
|
|
git.executable.notification.description=The path to Git executable is probably not valid.
|
|
git.executable.notification.cant.run.in.safe.mode=Cannot run a Git command in the safe mode
|
|
|
|
executable.error.git.not.installed=Git is not installed
|
|
executable.mac.fix.path.action=Fix Path
|
|
executable.mac.error.invalid.path.to.command.line.tools=Invalid path to Command Line Tools
|
|
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
vcs.history.action.gitlog=Show in Git Log
|
|
|
|
exportable.Git.Application.Settings.presentable.name=Git
|
|
|
|
git.add.to.exclude.file.action.text=.git/info/exclude
|
|
git.add.to.exclude.file.action.description=Add entries to .git/info/exclude
|
|
git.open.exclude.file.action.text=Open .git/info/exclude
|
|
git.open.exclude.file.action.description=Open .git/info/exclude in editor
|
|
|
|
git.fetch.progress=Fetching\u2026
|
|
|
|
action.CopyPathFromRepositoryRootProvider.text=Path From Repository Root
|
|
action.git4idea.commands.TestGitHttpLoginDialogAction.text=Test Git Login Dialog
|
|
action.Git.Log.DeepCompare.text=Not Cherry-Picked Commits
|
|
action.Git.Log.DeepCompare.description=Highlights commits which have not been cherry-picked to the current branch
|
|
group.Git.ContextMenu.text=_Git
|
|
group.Git.Menu.text=_Git
|
|
group.Git.MainMenu.RebaseActions.text=_Rebase
|
|
group.Git.MainMenu.MergeActions.text=_Merge
|
|
group.Git.MainMenu.LocalChanges.text=_Uncommitted Changes
|
|
action.Git.Rebase.Skip.text=Skip Commit
|
|
action.Git.Rebase.Skip.progress.title=Skip commit during rebase\u2026
|
|
action.Git.Rebase.Continue.text=Continue Rebase
|
|
action.Git.Revert.Abort.text=Abort Revert
|
|
action.Git.CherryPick.Abort.text=Abort Cherry-Pick
|
|
action.Git.Merge.Abort.text=Abort Merge
|
|
action.Git.Rebase.Abort.text=Abort Rebase
|
|
action.Git.Rebase.text=Rebase\u2026
|
|
action.Git.Rebase.operation.name=rebase
|
|
action.Git.Pull.text=Pull\u2026
|
|
action.Git.Fetch.text=Fetch
|
|
action.Git.Clone.text=Clone\u2026
|
|
action.Git.Configure.Remotes.text=Manage Remotes\u2026
|
|
action.Git.Reset.text=Reset HEAD\u2026
|
|
action.Git.Unstash.text=Unstash Changes\u2026
|
|
action.Git.Stash.text=Stash Changes\u2026
|
|
action.Git.Stash.Silently.text=Stash Silently
|
|
action.Git.Merge.text=Merge\u2026
|
|
action.Git.Tag.text=New Tag\u2026
|
|
action.Git.Push.Tag.text=Push Tag
|
|
action.Git.Push.Tag.text.to=Push to {0}{1,choice,0#|1# in {2}}
|
|
action.Git.Branches.text=_Branches\u2026
|
|
action.Git.ResolveConflicts.text=Resolve Conflicts\u2026
|
|
action.Git.CompareWithBranch.text=Compare with Branch or Tag\u2026
|
|
action.Git.Add.text=Add
|
|
action.Git.Interactive.Rebase.text=Interactively Rebase from Here\u2026
|
|
action.Git.Interactive.Rebase.description=Show the dialog for interactive rebase which allows to squash, fixup, reorder, remove and reword commits
|
|
action.Git.Squash.Into.Commit.text=Squash Into\u2026
|
|
action.Git.Squash.Into.Commit.description=Create a squash commit
|
|
action.Git.Fixup.To.Commit.text=Fixup\u2026
|
|
action.Git.Fixup.To.Commit.description=Create a fixup commit
|
|
action.Git.New.Branch.description=Select only one branch to proceed create a new branch
|
|
action.Git.New.Branch.dialog.title=Create Branch from {0}
|
|
action.Git.Update.Selected.text=Update Selected
|
|
action.Git.Update.Selected.description=Fetch from tracked remote and update selected {0,choice,1#branch|2#branches} using {1} or fast-forward like `git fetch branch:branch` if possible
|
|
action.Git.Update.Selected.description.already.running=Update is already running
|
|
action.Git.Update.Selected.description.select.non.current=Select non-current branches only
|
|
action.Git.Update.Selected.description.tracking.not.configured=Tracked branch is not configured for selected {0,choice,1#branch|2#branches}
|
|
action.Git.Delete.Branch.title=Delete {0,choice,1#Branch|2#Branches}
|
|
action.Git.Compare.With.Current.title=Compare with Current
|
|
action.Git.Compare.Selected.title=Compare Branches
|
|
action.Git.Compare.Selected.description=Compare selected branches with each other
|
|
action.Git.Compare.Selected.Heads.title=Show Files Diff
|
|
action.Git.Compare.Selected.Heads.description=Show diff between the selected branch heads
|
|
action.Git.Compare.Selected.description.disabled=Select branches from the same repository
|
|
action.Git.Show.My.Branches.title=Show My Branches
|
|
action.Git.Show.My.Branches.description.not.support.indexing=Some of the repositories doesn't support indexing.
|
|
action.Git.Show.My.Branches.description.not.all.roots.indexed=Not all repositories are indexed.
|
|
action.Git.Show.My.Branches.description.not.graph.ready=The log is not ready yet, please wait a bit.
|
|
action.Git.Show.My.Branches.description.is.my.branch=A branch is 'My' if all exclusive commits of this branch are made by 'me', i.e. by current Git author.
|
|
action.Git.Show.My.Branches.description.calculating.branches.progress=Calculating My Branches
|
|
action.Git.Fetch.title=Fetch All Remotes
|
|
action.Git.Fetch.description.fetch.in.progress=Fetch in progress\u2026
|
|
action.Git.Toggle.Favorite.title=Mark/Unmark As Favorite
|
|
action.Git.Loading.Branches.progress=Loading branches\u2026
|
|
group.Git.Log.Branches.Settings.text=Branches Pane Settings
|
|
group.Git.Log.Branches.Grouping.Settings.text=Group By
|
|
group.Git.Log.Branches.Settings.Separator.text=On Single Click
|
|
action.Git.Log.Branches.Change.Branch.Filter.On.Selection.text=Update Branch Filter
|
|
action.Git.Log.Branches.Change.Branch.Filter.On.Selection.description=When a branch is selected, filter the log by this branch
|
|
action.Git.Log.Branches.Navigate.Log.To.Branch.On.Selection.text=Navigate Log to Branch Head
|
|
action.Git.Log.Branches.Navigate.Log.To.Branch.On.Selection.description=When a branch is selected, navigate the log to this branch head
|
|
action.Git.Log.Branches.Navigate.Log.To.Selected.Branch.text=Navigate Log to Selected Branch Head
|
|
action.Git.Log.Branches.Change.Branch.Filter.text=Update Branch Filter in Log
|
|
action.Git.Log.Branches.Change.Branch.Filter.description=Update branch filter in log with selected branches
|
|
action.Git.Log.Edit.Remote.text=Edit Remote
|
|
action.Git.Log.Remove.Remote.text=Remove {0,choice,1#Remote|2#Remotes}
|
|
group.Git.HEAD.Branch.Filter.title=HEAD (Current Branch)
|
|
group.Git.Recent.Branch.title=Recent
|
|
group.Git.Recent.Branch.in.repo.title=Recent Branches in {0}
|
|
group.Git.Local.Branch.title=Local
|
|
group.Git.Remote.Branch.title=Remote
|
|
group.Git.Tags.title=Tags
|
|
group.Git.Tags.loading.text=Loading\u2026
|
|
action.Git.Log.Hide.Branches.text=Hide Git Branches
|
|
action.Git.Log.Show.Branches.text=Branches
|
|
action.Git.Reword.Commit.text=Edit Commit Message\u2026
|
|
action.Git.Reword.Commit.description=Change commit message via reword option of git rebase or amend
|
|
action.Git.Squash.Commits.text=Squash Commits\u2026
|
|
action.Git.Drop.Commits.text=Drop Commits
|
|
action.Git.Uncommit.text=Undo Commit\u2026
|
|
action.Git.Uncommit.description=Undo last commit and put its changes into selected changelist
|
|
action.Git.Revert.In.Log.text=Revert Commit
|
|
action.Git.Revert.In.Log.template.text=Revert {0,choice,1#Commit|2#Commits}
|
|
action.Git.Revert.In.Log.description=Produce a new commit(s), which reverts the changes made in the original commit(s)
|
|
action.Git.Reset.In.Log.text=Reset Current Branch to Here\u2026
|
|
action.Git.CreateNewTag.text=New Tag\u2026
|
|
action.Git.CreateNewTag.description=Create new tag pointing to this commit
|
|
action.Git.CreateNewBranch.text=New Branch\u2026
|
|
action.Git.CreateNewBranch.description=Create new branch starting from the selected commit
|
|
action.Git.PushUpToCommit.text=Push All up to Here\u2026
|
|
action.Git.PushUpToCommit.description=Push all previous commits including the selected one
|
|
group.Git.CheckoutGroup.text=Checkout
|
|
group.Git.CheckoutGroup.description=Checkout selected revision or a branch on selected commit
|
|
action.Git.BrowseRepoAtRevision.text=Show Repository at Revision
|
|
action.Git.Log.text=Show Git Repository Log\u2026
|
|
action.Git.Init.text=Create Git Repository\u2026
|
|
action.Git.Init.error=Git init failed
|
|
action.Git.Init.Stage.error=Adding files to Git failed
|
|
checkbox.dont.warn.again=Don't &warn again
|
|
checkbox.run.git.hooks=Run Git &hooks
|
|
tooltip.run.git.hooks=If unchecked, Git hooks will be skipped with the '--no-verify' parameter
|
|
action.NotificationAction.text.resolve=Resolve\u2026
|
|
action.NotificationAction.GitDeleteBranchOperation.text.restore=Restore
|
|
action.NotificationAction.GitDeleteBranchOperation.text.view.commits=View Commits
|
|
action.NotificationAction.GitDeleteBranchOperation.text.delete.tracked.branch=Delete Tracked Branch
|
|
action.NotificationAction.GitDeleteTagOperation.text.restore=Restore
|
|
action.NotificationAction.GithubNotifications.text.configure=Configure\u2026
|
|
action.NotificationAction.GitMergeAction.text.view.commits=View commits
|
|
action.NotificationAction.GitRewordOperation.text.undo=Undo
|
|
action.NotificationAction.GitUpdateSession.text.view.commits=View Commits
|
|
action.not.possible.in.fresh.repo.checkout=Checkout
|
|
action.main.toolbar.git.Branches.text=VCS Widget
|
|
action.main.toolbar.git.MergeRebase.text=VCS Merge/Rebase Widget
|
|
action.not.possible.in.fresh.repo.generic=Action
|
|
action.main.toolbar.git.project.not.trusted.separator.text=Safe mode, Version Control is not available
|
|
action.Git.Unshallow.text=Unshallow Repository
|
|
action.Git.Unshallow.progress.title=Unshallowing repository\u2026
|
|
action.Git.Unshallow.failure.title=Failed to unshallow repository
|
|
|
|
settings.git.option.group=Git
|
|
settings.commit.group.title=Commit
|
|
settings.push.group.title=Push
|
|
settings.update.group.title=Update
|
|
settings.add.suffix=Add the 'cherry-picked from <hash>' suffix when picking commits pushed to protected branches
|
|
settings.crlf=Warn if CRLF line separators are about to be committed
|
|
settings.detached.head=Warn when committing in detached HEAD or during rebase
|
|
settings.large.files=Warn when committing files larger than
|
|
settings.large.files.suffix=MB
|
|
settings.bad.file.names=Warn when committing files with names that might cause issues on other systems
|
|
settings.update.method=Update method:
|
|
settings.auto.update.on.push.rejected=Auto-update if push of the current branch was rejected
|
|
settings.push.dialog=Show Push dialog for Commit and Push
|
|
settings.push.dialog.for.protected.branches=Show Push dialog only when committing to protected branches
|
|
settings.protected.branched=Protected branches:
|
|
settings.protected.branched.validation=Skipped invalid protected branch pattern ''{0}'': {1}
|
|
settings.synchronize.branch.protection.rules=Load branch protection rules from GitHub
|
|
settings.synchronize.branch.protection.rules.description=GitHub rules are added to the local rules and synced on every fetch
|
|
settings.credential.helper=Use credential helper
|
|
settings.filter.update.info=Filter "Update Project" information by paths:
|
|
settings.explicitly.check=Explicitly check for incoming commits on remotes:
|
|
settings.explicitly.check.condition.comment=Requires ''{0}'' option to be enabled in Advanced Settings
|
|
settings.clean.working.tree=Clean working tree using:
|
|
settings.git.incoming.change.strategy.text.auto=Auto
|
|
settings.git.incoming.change.strategy.text.always=Always
|
|
settings.git.incoming.change.strategy.text.never=Never
|
|
settings.git.update.method.rebase.description=Rebase the current branch on top of incoming changes
|
|
settings.git.update.method.rebase=Rebase
|
|
settings.git.update.method.merge.description=Merge incoming changes into the current branch
|
|
settings.git.update.method.merge=Merge
|
|
settings.git.update.method.branch.default=Branch Default
|
|
settings.enable.staging.area=Enable staging area
|
|
settings.enable.staging.area.comment=This will disable changelists support. Only for non-modal commit interface.
|
|
settings.stash=Stash
|
|
settings.enable.stashes.and.shelves=Combine stashes and shelves in one tab
|
|
settings.stash.show.diff.group=When "Show Diff" is called, compare stashed changes:
|
|
settings.stash.show.diff.with.local=With the local version of a file
|
|
settings.stash.show.diff.with.head=With the parent commit
|
|
settings.show.rebase.log.drop.confirmation=Ask for confirmation to drop commits
|
|
settings.show.rebase.log.drop.confirmation.description=Applicable to Git
|
|
|
|
settings.label.sign.gpg.commits.no.roots.text=No Git roots in the project
|
|
settings.label.sign.gpg.commits.not.configured.text=Commits signing with GPG key is not configured
|
|
settings.label.sign.gpg.commits.enabled.text=Commits are signed with GPG key: {0}
|
|
settings.label.sign.gpg.commits.enabled.different.keys.text=Commits are signed with different GPG keys
|
|
settings.label.sign.gpg.commits.enabled.n.roots.of.m.text=Commits are signed with GPG key in {0} {0,choice,1#root|2#roots} of {1}
|
|
settings.sign.gpg.configure.link.text=Configure GPG Key\u2026
|
|
|
|
settings.configure.sign.gpg.synced.with.gitconfig.text=Synced with gitconfig
|
|
settings.configure.sign.gpg.for.repo.dialog.title=Configure GPG Key {0}
|
|
settings.configure.sign.gpg.for.repos.dialog.title=Configure GPG Keys
|
|
settings.configure.sign.gpg.with.key.checkbox.text=Sign commits with GPG key:
|
|
settings.configure.sign.gpg.root.table.column.name=Root
|
|
settings.configure.sign.gpg.gpg.kep.table.column.name=GPG key
|
|
settings.configure.sign.gpg.do.not.sign.table.text=Do not sign
|
|
settings.configure.sign.gpg.error.table.text=Error: {0}
|
|
settings.configure.sign.gpg.error.no.available.keys.found.text=Cannot find suitable private key
|
|
settings.configure.sign.gpg.loading.table.text=Loading\u2026
|
|
|
|
gpg.error.see.documentation.link.text=See GPG setup guide
|
|
gpg.jb.manual.link=Set_up_GPG_commit_signing
|
|
|
|
gpg.pinentry.title=Unlock GPG Private Key
|
|
gpg.pinentry.default.description=Please enter the passphrase to unlock the GPG private key:
|
|
|
|
clone.dialog.checking.git.version=Checking Git version\u2026
|
|
clone.dialog.shallow.clone=Shallow clone with a history truncated to
|
|
clone.dialog.shallow.clone.depth=commits
|
|
|
|
push.dialog.push.tags=Push &tags
|
|
push.dialog.push.tags.combo.current.branch=Current Branch
|
|
push.dialog.push.tags.combo.all=All
|
|
push.dialog.target.panel.define.remote=Define remote
|
|
push.dialog.target.panel.add.remote=Add Remote
|
|
push.dialog.target.panel.couldnt.add.remote=Could not add remote: {0}
|
|
push.dialog.target.panel.adding.remote=Adding Remote\u2026
|
|
push.dialog.target.panel.can.t.push=Cannot push
|
|
push.dialog.target.panel.empty.repository=Empty repository
|
|
push.dialog.target.panel.new=New
|
|
push.dialog.preview.commits.before.push=For Commit and Push to non-protected branches, preview commits before push
|
|
push.dialog.prohibited.branch.configurable.path={0} | Version Control | Git
|
|
push.local.history.system.label.after=After push
|
|
push.local.history.system.label.before=Before push
|
|
push.notification.description.force.pushed=Force pushed {0} to {1}
|
|
push.notification.description.new.branch.with.many.tags=Pushed {0} to new branch {1}, and {2} tags to {3}
|
|
push.notification.description.new.branch.with.single.tag=Pushed {0} to new branch {1}, and tag {2} to {3}
|
|
push.notification.description.new.branch=Pushed {0} to new branch {1}
|
|
push.notification.description.push.with.lease.rejected=Force-with-lease push {0} to {1} was rejected
|
|
push.notification.description.pushed.many.tags=Pushed {0} tags to {1}
|
|
push.notification.description.pushed.single.tag=Pushed tag {0} to {1}
|
|
push.notification.description.pushed.with.many.tags=Pushed {0} {0,choice,1#commit|2#commits} to {1}, and {2} tags to {3}
|
|
push.notification.description.pushed.with.single.tag=Pushed {0} {0,choice,1#commit|2#commits} to {1}, and tag {2} to {3}
|
|
push.notification.description.pushed=Pushed {0} {0,choice,1#commit|2#commits} to {1}
|
|
push.notification.description.rejected.and.cancelled=Push was rejected, and update was canceled
|
|
push.notification.description.rejected.and.conflicts=Push was canceled, because there were conflicts during the update.<br/>Check that conflicts were resolved correctly, and invoke push again.
|
|
push.notification.description.rejected.and.failed=Push was rejected, and update failed with an error
|
|
push.notification.description.rejected.and.incomplete=Push was canceled, because not all conflicts were resolved during the update.<br/>Resolve the conflicts and try pushing again
|
|
push.notification.description.rejected.by.remote=Push {0} to {1} was rejected by the remote
|
|
push.notification.description.rejected.by.remote.without.target=Push of {0} was rejected by the remote
|
|
push.notification.description.rejected=Push to {0} was rejected
|
|
push.notification.description.up.to.date=Everything is up to date
|
|
push.notification.force.push.anyway.action=Force push anyway
|
|
push.notification.force.push.progress.title.pushing=Pushing\u2026
|
|
push.notification.force.with.lease.help.description.first=Force-with-lease push prevents overriding remote changes that haven't been fetched to the local repository
|
|
push.notification.force.with.lease.help.description.second=Fetch recent changes to verify that they can be discarded safely and repeat the push operation
|
|
push.notification.force.with.lease.help=What Is Force-with-Lease?
|
|
push.notification.partially.failed.title=Push partially failed
|
|
push.notification.partially.rejected.title=Push partially rejected
|
|
push.notification.push.failed.title=Push failed
|
|
push.failed.error.message=Push failed: {0}
|
|
push.notification.rejected.title=Push rejected
|
|
push.notification.single.repo.success.description={0} {0,choice,1#commit|2#commits} received during the push operation
|
|
push.notification.successful.title=Push successful
|
|
push.notification.update.action=Update
|
|
push.notification.view.files.action=View files updated during the push
|
|
push.notification.view.filtered.commits.actions=View {0} {0,choice,1#commit|2#commits} matching the filter
|
|
push.notification.view.received.commits.action=View received {0,choice,1#commit|2#commits}
|
|
push.rejected.dialog.title=Push Rejected
|
|
push.rejected.many.repos.item={0} in {1}
|
|
push.rejected.many.repos.single.branch=Push of the current branch "{0}" was rejected.
|
|
push.rejected.many.repos=Push of the current branch was rejected:
|
|
push.rejected.merge.needed.with.problem=Remote changes need to be merged before pushing.<br/><br/>In this case <b>merge is highly recommended</b>, because there are non-pushed merge commits. <br/>Rebasing them can lead to problems.
|
|
push.rejected.merge.needed=Remote changes need to be merged before pushing.
|
|
push.rejected.merge=&Merge
|
|
push.rejected.only.one.git.repo=Push of the current branch "{0}" was rejected.
|
|
push.rejected.rebase.anyway=Rebase Anyway
|
|
push.rejected.rebase=&Rebase
|
|
push.upto.here.failed.dialog.title=Push Failed to Start
|
|
push.rejected.remember.checkbox=Remember the update method and update &silently in the future. Change this later in {0} | Version Control.<br/>
|
|
push.rejected.specific.repo=Push of the current branch "{0}" in repository "{1}" was rejected.
|
|
|
|
install.download.and.install.action=Download and Install
|
|
install.installing.progress=Installing\u2026
|
|
install.downloading.progress=Downloading\u2026
|
|
install.success.message=Git has been installed
|
|
install.general.error=Could not install Git
|
|
install.mac.error.couldnt.start.command.line.tools=Could not start Command Line Tools installation
|
|
install.mac.requesting.command.line.tools=Requesting XCode Command Line Developer Tools
|
|
git.status.not.changed=Not Changed
|
|
git.status.renamed=Renamed
|
|
git.status.copied=Copied
|
|
git.status.type.changed=Type Changed
|
|
git.status.unmerged=Unmerged
|
|
git.status.untracked=Untracked
|
|
git.status.index={0} in the staging area
|
|
git.status.work.tree={0} in the working directory
|
|
git.status.unmerged.index={0} by us
|
|
git.status.unmerged.work.tree={0} by them
|
|
git.status.unmerged.both=both {0}
|
|
|
|
git.status.bar.widget.name=Git Branch
|
|
git.status.bar.widget.text.cherry.pick=Cherry-picking in {0}
|
|
git.status.bar.widget.text.revert=Reverting in {0}
|
|
git.status.bar.widget.text.merge=Merging {0}
|
|
git.status.bar.widget.text.rebase=Rebasing {0}
|
|
git.status.bar.widget.tooltip.detached=Git: Detached HEAD doesn't point to any branch
|
|
git.status.bar.widget.tooltip.rebasing=Git: Rebase in progress
|
|
git.status.bar.widget.text.unknown=<unknown>
|
|
|
|
git.light.status.bar.display.name=Git
|
|
git.light.status.bar.tooltip=Current Git branch: {0}
|
|
git.light.status.bar.text=Git: {0}
|
|
git.light.cant.find.current.revision.exception.message=Cannot find the current revision for {0}
|
|
|
|
status.exception.message.unexpected.xstatus.ystatus=Unexpected symbol as status: ''{0}{1}''
|
|
status.exception.message.unexpected.status=Unexpected symbol as status: ''{0}''
|
|
status.exception.message.line.is.too.short=The line is too short
|
|
status.exception.message.unexpected=Unexpected symbol as status
|
|
status.exception.message.missing.path=Missing the original path
|
|
status.exception.message.format.message.xstatus.ystatus.line.output={0} xStatus=[{1}], yStatus=[{2}], line=[{3}]\noutput:\n{4}
|
|
|
|
output.parse.exception.unexpected.end.message=Unexpected text end at ''{0}''
|
|
|
|
stage.tree.node.staged=Staged
|
|
stage.tree.node.unstaged=Unstaged
|
|
stage.tree.node.unmerged=Unmerged
|
|
stage.tree.node.untracked=Untracked
|
|
stage.tree.node.ignored=Ignored
|
|
stage.content.staged=Staged
|
|
stage.content.local=Local
|
|
error.no.selected.roots.to.commit=Select roots to commit
|
|
error.no.staged.changes.to.commit=Stage files to commit
|
|
error.no.changed.files.to.commit=Modify files to commit
|
|
error.no.staged.changes.no.commit.message=Stage files to commit and specify commit message
|
|
error.no.changed.files.no.commit.message=Modify files to commit and specify commit message
|
|
error.unresolved.conflicts=Resolve conflicts in order to commit
|
|
stage.commit.process=Committing Staged Changes\u2026
|
|
stage.commit.successful=Committed {0}: {1}
|
|
stage.commit.failed=Failed to commit {0}
|
|
stage.loading.status=Loading changes\u2026
|
|
stage.default.status=Nothing to commit, working tree is clean
|
|
stage.default.status.help=Getting started with staging area
|
|
stage.add.action.text=Stage
|
|
stage.add.process=Staging Files\u2026
|
|
stage.add.error.title=Failed to Stage Files
|
|
stage.add.no.content.action.text=Stage Without Content
|
|
stage.reset.action.text=Unstage
|
|
stage.reset.process=Unstaging Files\u2026
|
|
stage.reset.error.title=Failed to Unstage Files
|
|
stage.revert.action.text=Rollback
|
|
stage.revert.process=Rolling Back Files\u2026
|
|
stage.revert.error.title=Failed to Rollback Files
|
|
stage.add.range.command.name=Stage Changes
|
|
stage.revert.unstaged.range.command.name=Rollback Unstaged Change
|
|
stage.revert.staged.range.command.name=Rollback Staged Change
|
|
action.label.add.unstaged.range=Stage
|
|
action.label.add.unstaged.range.tooltip=Add new changes to index
|
|
action.label.reset.staged.range=Unstage
|
|
action.label.reset.staged.range.tooltip=Remove changes from index
|
|
stage.vfs.write.process=Writing {0} to Git index
|
|
stage.vfs.read.process=Reading {0} from Git index
|
|
stage.vfs.shutdown.process=Shutting down Git index VFS
|
|
stage.vfs.presentable.file.name=Staged: {0}
|
|
stage.vfs.editor.tab.tooltip=Staged Version of ''{0}''
|
|
stage.vfs.editor.notification.text=This is a staged version of ''{0}''
|
|
stage.vfs.editor.notification.link=Open local version
|
|
stage.diff.local.content.exception.message=Cannot get local file: ''{0}''
|
|
stage.diff.staged.content.exception.message=Cannot get staged content: ''{0}''
|
|
changes.view.merge.action.text=Merge
|
|
stage.commit.all.text=Comm&it All
|
|
|
|
action.Git.Show.Stage.text=Show Staging Area
|
|
action.Git.Commit.Stage.text=Commit\u2026
|
|
action.Git.Stage.Add.All.text=Stage All
|
|
action.Git.Stage.Add.All.description=Add all unstaged changes and untracked files to index
|
|
action.Git.Stage.Add.Tracked.text=Stage All Tracked
|
|
action.Git.Stage.Add.Tracked.description=Add all unstaged changes in tracked files to index
|
|
group.Git.Stage.Ui.Settings.text=View Options
|
|
action.Git.Stage.ToggleCommitAll.text=Commit All when Nothing Is Staged
|
|
action.Git.Stage.ToggleCommitAll.description=Commit all files when there are no staged files
|
|
action.Git.Stage.Show.Staged.text=Show Staged Version
|
|
action.Git.Stage.Show.Staged.description=Show editor with staged content of the current file
|
|
action.Git.Stage.Show.Local.text=Show Local Version
|
|
action.Git.Stage.Show.Local.description=Show editor with local content for the current file
|
|
action.Git.Stage.Compare.Local.Staged.text=Compare with Staged Version
|
|
action.Git.Stage.Compare.Staged.Local.text=Compare with Local Version
|
|
action.Git.Stage.Compare.Staged.Head.text=Compare with HEAD Version
|
|
action.Git.Stage.Compare.Three.Versions.text=Compare HEAD, Staged and Local Versions
|
|
action.Git.Stage.ThreeSideDiff.text=Compare HEAD, Staged and Local Versions
|
|
action.Git.Stage.ThreeSideDiff.description=Show diff window with HEAD, staged and local versions that allows to interactively add changes into staging area
|
|
group.Git.Stage.Index.File.Menu.text=Git
|
|
separator.show=Show
|
|
group.Git.Stage.Configure.text=Configure Local Changes
|
|
separator.Git.Stage.Configure.display.as=Display as
|
|
action.Git.Stage.Enable.text=Staging Area
|
|
action.Git.Stage.Enable.description=Use the native Git concept of staging for making commits
|
|
action.Git.Stage.Disable.text=Changelists
|
|
action.Git.Stage.Disable.description=Disable staging area and switch to changelists
|
|
|
|
branches.selected.branches.updated.title=Updated {0,choice,1#branch|2#branches}:\n\n{1}
|
|
branches.update.failed=Update failed
|
|
branches.updating.process=Updating branches\u2026
|
|
branches.checking.existing.commits.process=Checking existing commits\u2026
|
|
branches.create.new.branch.dialog.title=Create New Branch
|
|
branches.tag.0=Tag ''{0}''
|
|
branches.branch.0=Branch ''{0}''
|
|
in.branches.all.repositories=In All Repositories
|
|
branches.tags=Tags
|
|
branches.branches=Branches
|
|
repositories=Repositories
|
|
common.tags=Common Tags
|
|
common.remote.branches=Common Remote Branches
|
|
common.local.branches=Common Local Branches
|
|
update.checks.not.supported.git.2.9.required=Update Checks not Supported. Git 2.9+ Required
|
|
action.fetch.text=Fetch
|
|
fetching=Fetching\u2026
|
|
branches.current.branch=current branch
|
|
branches.tracking.branch.doesn.t.configured.for.s=Tracked branch is not configured for {0}
|
|
branches.update.is.already.running=Update is already running
|
|
branches.update=Update
|
|
branches.current.branch.name=Current
|
|
branches.selected.branch.name=Selected
|
|
branches.checkout.and.rebase.failed=Checkout and Rebase failed
|
|
branches.checkout.and.rebase.error.current.with.same.name=Cannot overwrite current branch {0}
|
|
branches.checkout.and.rebase.onto.current.process=Checking out {0} out and rebasing onto current
|
|
branches.checkout.and.rebase.onto.in.one.step=Checkout {0}, and rebase it onto {1} in one step (like `git rebase HEAD {2}`)
|
|
branches.checkout.and.rebase.onto.current=Checkout and Rebase onto Current
|
|
branches.checkout.and.rebase.onto.branch=Checkout and Rebase onto {0}
|
|
branches.rebase.is.not.possible.in.the.detached.head.state=Rebase is not possible in the detached HEAD state
|
|
branches.rebase.onto=Rebase {0} onto {1}
|
|
branches.rebase.onto.selected.commit=Rebase {0} onto Selected Commit
|
|
branches.rebase.onto.selected.commit.description=Rebase {0} onto {1}
|
|
branches.rebase.current.onto.selected=Rebase Current onto Selected
|
|
branches.merge.into=Merge {0} into {1}
|
|
branches.merge.into.current=Merge into Current
|
|
branches.compare.the.current.working.tree.with=Compare the current working tree with the tree in {0}
|
|
branches.show.diff.with.working.tree=Show Diff with Working Tree
|
|
branches.show.commits.in=Show commits in {0} that are missing in {1}
|
|
branches.compare.with.current=Compare with Current
|
|
branches.compare.with.branch=Compare with {0}
|
|
branches.new.branch.from.branch=New Branch from {0}\u2026
|
|
branches.new.branch.from.branch.current=New Branch from Current\u2026
|
|
branches.new.branch.from.branch.description=Create new branch from {0}
|
|
branches.checkout.s=Checkout {0}
|
|
checkout.and.rebase=Rebase onto Remote
|
|
checkout.0=Checkout {0}
|
|
branches.checkout.local.has.more.commits=Local branch ''{0}'' has commits that do not exist in ''{1}''. Rebase ''{0}'' onto ''{1}'', or checkout ''{0}''?
|
|
branches.checkout.with.reset.local.has.more.commits=Local branch ''{0}'' has commits that do not exist in ''{1}''. Rebase ''{0}'' onto ''{1}'', or drop local commits?
|
|
branches.create.local.has.more.commits=Local branch ''{0}'' has commits that do not exist in ''{1}''. Do you want to create a branch in other repositories?
|
|
branches.create.with.reset.local.has.more.commits=Local branch ''{0}'' has commits that do not exist in ''{1}''. Do you want to drop local commits?
|
|
branches.drop.local.commits=Drop Local Commits
|
|
branches.checkout=Checkout
|
|
branches.checkout.local=Checkout Local Branch
|
|
branches.rename.branch=Rename Branch {0}
|
|
branches.there.are.outgoing.commits=There are outgoing commits
|
|
branches.there.are.incoming.commits=There are incoming commits
|
|
branches.there.are.incoming.and.outgoing.commits=There are incoming and outgoing commits
|
|
branches.tooltip.number.incoming.commits={0} incoming {0,choice,1#commit|2#commits}
|
|
branches.tooltip.number.outgoing.commits={0} outgoing {0,choice,1#commit|2#commits}
|
|
branches.tooltip.some.incoming.commits.not.fetched=Some incoming commits are not fetched
|
|
branches.tooltip.number.incoming.commits.in.repositories={0} incoming {0,choice,1#commit|2#commits} in {1} {1, choice, 1#repository|2#repositories}
|
|
branches.tooltip.number.outgoing.commits.in.repositories={0} outgoing {0,choice,1#commit|2#commits} in {1} {1, choice, 1#repository|2#repositories}
|
|
branches.checkout.tag.or.revision=Checkout Tag or Revision\u2026
|
|
branches.enter.reference.branch.tag.name.or.commit.hash=Enter reference (branch, tag) name or commit hash:
|
|
branches.remote.branches=Remote Branches
|
|
branches.tags.in.repo=Tags in {0}
|
|
branches.remote.branches.in.repo=Remote Branches in {0}
|
|
branches.local.branches=Local Branches
|
|
branches.local.branches.in.repo=Local Branches in {0}
|
|
branches.update.info.process=Update branches info\u2026
|
|
branches.action.pull.into.branch.using.merge=Pull into {0} Using Merge
|
|
branches.action.pull.into.branch.using.merge.selected=Pull Into Selected Using Merge
|
|
branches.action.pull.into.branch.using.merge.description=Pull into {0} Using Merge
|
|
branches.action.pull.into.branch.using.rebase=Pull into {0} Using Rebase
|
|
branches.action.pull.into.branch.using.rebase.selected=Pull Into Selected Using Rebase
|
|
branches.action.pull.into.branch.using.rebase.description=Pull into {0} Using Rebase
|
|
branches.action.delete=&Delete
|
|
git.rollback=&Rollback
|
|
|
|
new.branch.dialog.operation.create.name=Create
|
|
new.branch.dialog.operation.create.description=Create new branches in other repositories
|
|
new.branch.dialog.operation.checkout.name=Checkout
|
|
new.branch.dialog.operation.checkout.description=Checkout existing branches, and create new branches in other repositories
|
|
new.branch.dialog.operation.rename.name=Rename
|
|
new.branch.dialog.branch.name=New branch name:
|
|
new.branch.dialog.checkout.branch.checkbox=&Checkout branch
|
|
new.branch.dialog.set.tracking.branch.checkbox=Set &tracking branch
|
|
new.branch.dialog.overwrite.existing.branch.checkbox=Ove&rwrite existing branch
|
|
new.branch.dialog.overwrite.existing.branch.warning=Change the name or overwrite existing branch
|
|
new.branch.dialog.error.branch.name.invalid=Branch name {0} is not valid
|
|
new.branch.dialog.error.branch.name.empty=Specify name for the new branch
|
|
new.branch.dialog.error.branch.name.head=HEAD is a reserved keyword
|
|
new.branch.dialog.error.branch.already.exists=Branch name {0} already exists
|
|
new.branch.dialog.error.branch.clashes.with.remote=Branch name {0} conflicts with remote branch with the same name
|
|
new.branch.dialog.error.branch.clashes.with.directory=Branch name {0} conflicts with local branch directory with the same name
|
|
git.reset.mode.soft=Soft
|
|
git.reset.mode.soft.description=Files won't change, differences will be staged for commit.
|
|
git.reset.mode.mixed=Mixed
|
|
git.reset.mode.mixed.description=Files won't change, differences won't be staged.
|
|
git.reset.mode.hard=Hard
|
|
git.reset.mode.hard.description=<nobr>Files will be reverted to the state of the selected commit.<nobr/><br><nobr>Warning: any local changes will be lost.<nobr/>
|
|
git.reset.mode.keep=Keep
|
|
git.reset.mode.keep.description=<nobr>Files will be reverted to the state of the selected commit,<nobr/><br><nobr>but local changes will be kept intact.<nobr/>
|
|
git.reset.dialog.title=Git Reset
|
|
git.reset.dialog.description=<nobr>This will reset the current branch head to the selected commit,<nobr/><br><nobr>and update the working tree and the index according to the selected mode:<nobr/>
|
|
git.reset.dialog.description.commit.details.by.author={0} by {1}
|
|
git.reset.dialog.description.source.in.repository={0} in {1}
|
|
git.reset.process=Git Reset
|
|
git.reset.operation=reset
|
|
git.reset.button=Reset
|
|
git.reset.hard.button=&Hard Reset
|
|
git.reset.successful.notification.message=Reset successful
|
|
git.reset.partially.failed.notification.title=Reset partially failed
|
|
git.reset.partially.failed.notification.msg=Reset was successful for {0}\n\
|
|
but failed for {1}:\n\
|
|
{2}
|
|
git.reset.failed.notification.title=Reset failed
|
|
git.undo.action.operation=undo commit
|
|
git.undo.action.successful.notification.message=Undo commit successful
|
|
git.undo.action.failed.notification.title=Undo commit failed
|
|
git.undo.action.cant.undo.commit.failure=Cannot Undo Commit
|
|
git.undo.action.description=The selected commit is not the last in the current branch
|
|
git.undo.action.select.target.changelist.title=Select Target Changelist
|
|
git.undo.action.undoing.last.commit.process=Undoing Last Commit\u2026
|
|
git.undo.action.refreshing.changes.process=Refreshing Changes\u2026
|
|
git.undo.action.could.not.load.changes.of.commit=Could not load changes of {0}
|
|
git.new.tag.dialog.title=Create New Tag On {0}
|
|
git.new.tag.dialog.tag.name.label=Enter the name of new tag
|
|
git.compare.with.tag.modal.progress.loading.tags=Loading Tags\u2026
|
|
git.compare.with.tag.loading.error.title=Cannot load tags
|
|
git.compare.with.tag.popup.title=Select Tag to Compare
|
|
git.compare.with.tag.file.not.found.in.tag={0,choice,1#File|2#Directory} {1} doesn''t exist in tag ''{2}''
|
|
|
|
git.log.external.tab.description=Log for {0}
|
|
git.log.external.window.title=Git Log
|
|
git.log.external.loading.process=Loading Git Log\u2026
|
|
|
|
git.log.cherry.picked.highlighter.select.branch.popup=Select Source Branch
|
|
git.log.cherry.picked.highlighter.process=Comparing Branches\u2026
|
|
git.log.cherry.picked.highlighter.error.message=Could not compare with branch {0}
|
|
git.log.cherry.picked.highlighter.cancelled.message=Highlighting of non-picked commits in ''{0}'' has been cancelled, \
|
|
as branch filter was changed.
|
|
|
|
git.log.action.checkout.group=Checkout
|
|
git.log.action.checkout.revision.short.text=Revision ''{0}''
|
|
git.log.action.checkout.revision.full.text=Checkout Revision ''{0}''
|
|
action.Git.CheckoutRevision.text=Checkout Revision
|
|
|
|
git.log.diff.handler.changes.between.revisions.title=Changes Between {0} and {1}
|
|
git.log.diff.handler.changes.between.revisions.in.paths.title=Changes Between {0} and {1} in {2}
|
|
git.log.diff.handler.local.version.name=local version
|
|
git.log.diff.handler.local.version.content.title=Local
|
|
|
|
git.log.refGroup.local=Local
|
|
|
|
git.log.branches.search.field.accessible.name=Git branches search
|
|
git.log.branches.search.field.accessible.description=Press {0} to go to VCS log table filter
|
|
git.log.branches.tree.accessible.name=Git branches
|
|
|
|
git.branches.popup.tree.accessible.name=Branches Tree
|
|
git.branches.popup.tree.no.branches=Branch ''{0}'' not found
|
|
git.branches.popup.tree.no.nodes=''{0}'' not found
|
|
git.branches.popup.show.recent.branches.action.name=Show Recent Branches
|
|
git.branches.popup.show.tags.name=Show Tags
|
|
separator.git.branches.popup.filter.by=Add in Search Results
|
|
action.git.branches.popup.filter.by.action.single.text=Show Actions in Search Results
|
|
action.git.branches.popup.filter.by.action.text=Actions
|
|
action.git.branches.popup.filter.by.repository.text=Repositories
|
|
git.branches.popup.search.field.empty.text=Search for branches{0}{1}
|
|
git.branches.popup.search.field.actions.empty.text={0,choice,1# and|2#,} actions
|
|
git.branches.popup.search.field.repositories.empty.text={0,choice,1# and|2#,} repositories
|
|
git.branches.popup.loading.tags=Loading Git tags\u2026
|
|
|
|
column.name.commit.signature=GPG Signature
|
|
|
|
commit.signature.none=No GPG signature
|
|
commit.signature.bad=Bad GPG signature
|
|
commit.signature.unverified=Unverified GPG signature
|
|
commit.signature.unverified.with.reason=Unverified GPG signature: {0}
|
|
commit.signature.verified=Verified GPG signature
|
|
|
|
|
|
commit.signature.unverified.reason.unknown=unknown validity
|
|
commit.signature.unverified.reason.expired=expired signature
|
|
commit.signature.unverified.reason.expired.key=made with expired key
|
|
commit.signature.unverified.reason.revoked.key=made with revoked key
|
|
commit.signature.unverified.reason.cannot.verify=cannot verify (e.g. missing key)
|
|
|
|
commit.signature.fingerprint=Signature fingerprint:
|
|
commit.signature.signed.by=Signed by:
|
|
|
|
log.parser.exception.message.error.parsing.line=Error while parsing line "{0}"
|
|
log.parser.exception.message.could.not.parse.output=Cannot not parse Git log output "{0}"
|
|
log.parser.exception.message.error.command.line={0}\nCommand line: [{1}]
|
|
|
|
history.filters.unsupported.error.message=Filtering history by "{0}" is not supported
|
|
history.for.revision.filters.unsupported.error.message=Filtering history for revision by "{0}" is not supported
|
|
|
|
git.history.diff.handler.choose.parent.popup=Choose Parent to Compare
|
|
git.history.diff.handler.load.changes.process=Loading changes\u2026
|
|
git.history.diff.handler.git.show.error=Error happened while executing git show {0}:{1}
|
|
git.history.diff.handler.no.changes.in.file.info=There are no changes to file {0} in this merge commit
|
|
# suppress inspection "UnusedProperty": used by 3-party plugins
|
|
git.log.show.commit.in.log.process=Searching for Revision {0}
|
|
git.compare.branches.empty.status={0} contains all commits from {1}
|
|
git.compare.branches.explanation.message=Commits that exist in {0} but don''t exist in {1}
|
|
git.compare.branches.tab.name=Compare
|
|
git.compare.branches.tab.suffix={0} and {1}
|
|
git.compare.with.branch.search.field.empty.text=Search for branches{0,choice,0#|1# and tags}
|
|
git.compare.with.branch.search.not.found=''{0}'' not found
|
|
git.update.files.updated.in.commits={0,choice,1#{0} file|2#{0} files} updated in {1,choice,1#{1} commit|2#{1} commits}
|
|
git.update.no.commits.matching.filters=No commits matching filters
|
|
git.update.commits.matching.filters={0,choice,1#{0} commit|2#{0} commits} matching filters
|
|
git.update.project.partially.updated.title=Project Partially Updated
|
|
git.update.skipped.repositories=Skipped {0} repositories:
|
|
git.update.repo.was.skipped={0} was skipped ({1})
|
|
|
|
git.integration.created.git.repository.in=Created Git repository in {0}
|
|
git.integration.could.not.git.init=Could not git init {0}
|
|
|
|
git.tag.could.not.create.tag=Could not create tag
|
|
git.tag.created.tag.successfully=Created tag {0} successfully.
|
|
|
|
rename.branch.operation.name=rename
|
|
git.rename.branch.rollback.successful=Rollback successful
|
|
git.rename.branch.renamed.back.to=Renamed back to {0}
|
|
git.rename.branch.rollback.failed=Rollback failed
|
|
git.rename.branch.could.not.rename.from.to=Could not rename {0} to {1}
|
|
git.rename.branch.was.renamed.to=Branch {0} was renamed to {1}
|
|
git.rename.branch.you.may.rename.branch.back=You may rollback (rename branch back to {0}) not to let branches diverge.
|
|
git.rename.branch.has.succeeded.for.the.following.repositories=However, rename has succeeded for the following {0,choice,1#repository|2#repositories}:
|
|
|
|
update.process.progress.title=Updating\u2026
|
|
update.process.generic.error.title=Cannot update
|
|
update.process.error.message.unfinished.merge=You have unfinished merge. These conflicts must be resolved before update.
|
|
update.process.error.message.unmerged.files=Unmerged files detected. These conflicts must be resolved before update.
|
|
update.process.error.description.unfinished.rebase=You have unfinished rebase process. These conflicts must be resolved before update.
|
|
update.process.error.additional.description.unfinished.rebase=Then you may <b>continue rebase</b>. <br/> You also may <b>abort rebase</b> to restore the original branch and stop rebasing.
|
|
update.process.nothing.to.update=Nothing to update
|
|
update.process.error.notification.title=Cannot set an upstream branch
|
|
|
|
checkout.operation.could.not.checkout.error=Could not checkout {0}
|
|
checkout.operation.revision.not.found=Revision not found{0,choice,0#|1# in {1}}
|
|
checkout.operation.rollback.action=Rollback
|
|
checkout.operation.could.not.checkout.error.title=Could not checkout {0}
|
|
checkout.operation.checked.out=Checked out {0}
|
|
checkout.operation.checked.out.new.branch.from=Checked out new branch {0} from {1}
|
|
checkout.operation.in={0}{1,choice,0#|1# in {2}}
|
|
checkout.operation.force.checkout=&Force Checkout
|
|
checkout.operation.name=checkout
|
|
checkout.operation.error.during.rollback=Error during rollback
|
|
checkout.operation.errors.during.deleting=Errors during deleting {0}:
|
|
checkout.operation.errors.during.checkout=Errors during checkout:
|
|
checkout.operation.you.may.rollback.not.to.let.branches.diverge=You may rollback (checkout back to {0}) not to let branches diverge.
|
|
checkout.operation.previous.branch=previous branch
|
|
checkout.operation.however.checkout.has.succeeded.for.the.following=However, checkout has succeeded for the following {0,choice,1#repository|2#repositories}:
|
|
|
|
delete.branch.operation.collecting.unmerged.commits.process=Collecting unmerged commits\u2026
|
|
delete.branch.operation.restoring.branch.process=Restoring Branch {0}\u2026
|
|
delete.branch.operation.error.during.rollback.of.branch.deletion=Error during rollback of branch deletion
|
|
delete.branch.operation.could.not.restore.branch.error=Could not Restore {0}
|
|
delete.branch.operation.branch.was.not.deleted.error=Branch {0} wasn''t deleted
|
|
delete.branch.operation.deleted.branch=Deleted branch {0}
|
|
delete.branch.operation.deleted.branch.bold=<b>Deleted Branch:</b> {0}
|
|
delete.branch.operation.unmerged.commits.were.discarded=Unmerged commits were discarded
|
|
delete.branch.operation.however.branch.deletion.has.succeeded.for.the.following=However, branch deletion has succeeded for the following {0,choice,1#repository|2#repositories}:
|
|
delete.branch.operation.you.may.rollback.not.to.let.branches.diverge=You may rollback (recreate {0} in these roots) not to let branches diverge.
|
|
|
|
branch.operation.could.not.0.operation.name.1.reference=Could not {0} {1}
|
|
branch.operation.in={0} (in {1})
|
|
|
|
checkout.new.branch.operation.could.not.create.new.branch=Could not create new branch {0}
|
|
checkout.new.branch.operation.error.during.rollback=Error during rollback
|
|
checkout.new.branch.operation.errors.during.deleting=Errors during deleting {0}:
|
|
checkout.new.branch.operation.errors.during.checkout=Errors during checkout:
|
|
checkout.new.branch.operation.rollback.successful=Rollback successful
|
|
checkout.new.branch.operation.checked.out.0.and.deleted.1.on.2.3=Checked out {0} and deleted {1} on {2,choice,1#root|2#roots} {3}
|
|
checkout.new.branch.operation.branch.was.created=Branch {0} was created
|
|
checkout.new.branch.operation.however.checkout.has.succeeded.for.the.following=However, checkout has succeeded for the {0,choice,1#repository|2#repositories}:
|
|
checkout.new.branch.operation.you.may.rollback.not.to.let.branches.diverge=You may rollback (checkout previous branch back, and delete {0}) not to let branches diverge.
|
|
|
|
delete.branch.operation.name=branch deletion
|
|
delete.remote.branch.operation.deleting.process=Deleting {0}
|
|
delete.remote.branch.operation.deleted.remote.branch=Deleted remote branch {0}
|
|
delete.remote.branch.operation.also.deleted.local.branches=Also deleted local {0,choice,1#branch|2#branches}: {1}
|
|
delete.remote.branch.operation.failed.to.delete.remote.branch=Failed to delete remote branch {0}
|
|
delete.remote.branch.operation.couldn.t.find.remote.by.name=Could not find remote by name: {0}
|
|
|
|
delete.remote.tag.operation.deleted.tag.on.remotes=<b>Deleted Tag on {0,choice,1#Remote|2#Remotes}:</b> {1}
|
|
delete.remote.tag.operation.tag.does.not.exist.on.remotes=<b>Tag Doesn''t Exist on {0,choice,1#Remote|2#Remotes}:</b> {1}
|
|
delete.remote.tag.operation.failed.to.delete.tag.on.remotes=Failed to delete tag {0} on {1,choice,1#Remote|2#Remotes}
|
|
|
|
merge.dialog.description.cherry.pick.label.text=Conflicts during cherry-picking {0,choice,1#commit {1}|2#multiple commits}{2,choice,0#|1# made by {3}{4}}
|
|
merge.dialog.description.merge.label.text=Merging {0,choice,1#branch {1}|2#diverging branches} into {2,choice,1#branch {3}|2#diverging branches}
|
|
merge.dialog.description.rebase.with.hash.label.text=Rebasing{0,choice,0#|1# branch {1}} onto {2}
|
|
merge.dialog.description.rebase.with.onto.branch.label.text=Rebasing{0,choice,0#|1# branch {1}} onto branch {2}{3,choice,0#|1#, revision {4}}
|
|
merge.dialog.description.rebase.without.onto.info.label.text=Rebasing{0,choice,0#|1# branch {1}} onto diverging branches
|
|
merge.dialog.diff.left.title.cherry.pick.label.text=Local Changes
|
|
merge.dialog.diff.left.title.default.branch.label.text=Your version, branch {0}
|
|
merge.dialog.diff.left.title.rebase.label.text=Rebasing {0} from {1}
|
|
merge.dialog.diff.right.title.cherry.pick.label.text=Changes from cherry-pick {0}
|
|
merge.dialog.diff.right.title.default.with.hash.label.text=Changes from {0}
|
|
merge.dialog.diff.right.title.default.with.onto.branch.label.text=Changes from branch {0}{1,choice,0#|1#, revision {2}}
|
|
merge.dialog.diff.right.title.default.without.onto.info.label.text=Changes from diverging branches
|
|
merge.dialog.diff.right.title.rebase.with.branch.label.text=Already rebased commits and commits from {0}
|
|
merge.dialog.diff.right.title.rebase.without.branch.label.text=Already rebased commits
|
|
merge.dialog.diff.title.changes.from.branch.label.text=Changes from {0}
|
|
merge.error.unable.to.read.merge.head=Unable to read the file {0}: {1}
|
|
merge.operation.name=merge
|
|
rebase.operation.name=rebase
|
|
unstash.operation.name=unstash
|
|
merge.operation.you.may.rollback.not.to.let.branches.diverge=You may rollback (reset to the commit before merging) not to let branches diverge.
|
|
merge.operation.error.during.rollback=Error during rollback
|
|
merge.operation.branch.merged.with.conflicts={0} Merged with Conflicts
|
|
merge.operation.could.not.merge.branch=Could Not Merge {0}
|
|
merge.operation.already.up.to.date=Already up to date
|
|
merge.operation.however.merge.has.succeeded.for.the.following.repositories=However, merge has succeeded for the following {0,choice,1#repository|2#repositories}:
|
|
merge.operation.merged.to=Merged {0} to {1}
|
|
merge.operation.delete.branch.action=Delete {0}
|
|
merge.progress.indicator.loading.unmerged.files.title=Loading unmerged files\u2026
|
|
|
|
merge.unresolved.conflicts.remaining.notification.title=Pending Unresolved conflicts
|
|
merge.unresolved.conflicts.remaining.notification.body=There are pending unresolved conflicts.
|
|
|
|
create.branch.operation.name=create branch
|
|
create.branch.operation.could.not.create.new.branch=Could not create new branch {0}
|
|
create.branch.operation.rollback.successful=Rollback successful
|
|
create.branch.operation.deleted.branch=Deleted {0}
|
|
create.branch.operation.error.during.rollback=Error during rollback
|
|
create.branch.operation.branch.created=Branch {0} was created
|
|
create.branch.operation.however.the.branch.was.created.in.the.following.repositories=However, the branch was created in the following {0,choice,1#repository|2#repositories}:
|
|
create.branch.operation.you.may.rollback.not.to.let.branches.diverge=You may rollback (delete {0}) not to let branches diverge.
|
|
|
|
branch.ui.handler.can.not.operation.name.because.of.unmerged.files=Cannot {0} because of unmerged files
|
|
branch.ui.handler.unmerged.files.error.notification.text=You need to resolve all merge conflicts before {0}.<br/>After resolving conflicts do not forget to commit your files to the current branch before switching to another branch.
|
|
branch.ui.handler.unmerged.files.error.resolve.conflicts.action.text=Resolve conflicts\u2026
|
|
branch.ui.handler.merge.notification.description=The following files have unresolved conflicts. You need to resolve them before {0}.
|
|
branch.ui.handler.merge.error.notification.title=Unresolved files remain.
|
|
branch.ui.handler.rollback=Rollback
|
|
branch.ui.handler.do.not.rollback=Don't Rollback
|
|
branch.ui.handler.you.have.to.resolve.all.conflicts.before.operation.name=You need to resolve all merge conflicts before {0}.<br/>{1}
|
|
branch.ui.handler.delete.remote.branches=Delete Remote {0,choice,1#Branch|2#Branches}
|
|
branch.ui.handler.delete.all=Delete All
|
|
branch.ui.handler.delete.remote.branches.question=Delete remote {0,choice,1#branch|2#branches} {1}?
|
|
branch.ui.handler.delete.tracking.local.branch.as.well=Delete tracking local branch {0} as well
|
|
branch.ui.handler.delete.tracking.local.branches=Delete tracking local branches:
|
|
|
|
delete.tag.operation.could.not.restore.tag=Could not Restore {0}
|
|
delete.tag.operation.error.during.rollback.of.tag.deletion=Error during rollback of tag deletion
|
|
delete.tag.operation.restored.tag=Restored tag {0}
|
|
delete.tag.operation.rollback.successful=Rollback Successful
|
|
delete.tag.operation.restoring.tag.process=Restoring Tag {0}\u2026
|
|
delete.tag.operation.deleted.tag=<b>Deleted Tag:</b> {0}
|
|
delete.tag.operation.delete.on.remote=Delete on {0,choice,1#Remote|2#Remotes}
|
|
delete.tag.operation.could.not.find.tag=Could not find tag {0}
|
|
delete.tag.operation.could.not.find.tag.in=Could not find tag in {0}
|
|
delete.tag.operation.tag.was.not.deleted=Tag {0} wasn''t deleted
|
|
delete.tag.operation.however.tag.deletion.has.succeeded.for.the.following=However, tag deletion has succeeded for the following {0,choice,1#repository|2#repositories}:
|
|
delete.tag.operation.you.may.rollback.not.to.let.tags.diverge=You may rollback (recreate {0} in these roots) not to let tags diverge.
|
|
|
|
branch.renaming.branch.process=Renaming {0} to {1}\u2026
|
|
branch.rebasing.process=Rebasing {0}\u2026
|
|
branch.rebasing.onto.process=Rebasing onto {0}\u2026
|
|
branch.merging.process=Merging {0}\u2026
|
|
branch.deleting.tag.process=Deleting tag {0}\u2026
|
|
branch.deleting.tag.on.remote.process=Deleting tag {0} on remote\u2026
|
|
branch.deleting.remote.branch=Deleting {0}\u2026
|
|
branch.deleting.branch.process=Deleting {0}\u2026
|
|
branch.checking.out.new.branch.process=Checking out new branch {0}\u2026
|
|
branch.creating.branch.process=Creating branch {0}\u2026
|
|
branch.checking.out.branch.from.process=Checking out {0} from {1}\u2026
|
|
branch.checking.out.process=Checking out {0}\u2026
|
|
|
|
branch.not.fully.merged.dialog.repository.label=Repository:
|
|
branch.not.fully.merged.dialog.title=Branch Was Not Fully Merged
|
|
branch.not.fully.merged.dialog.restore.button=&Restore
|
|
branch.not.fully.merged.dialog.all.commits.from.branch.were.merged=All commits from branch {0} were merged
|
|
branch.not.fully.merged.dialog.the.branch.was.not.fully.merged.to=The branch {0} was not fully merged to {1}.<br/>Below is the list of unmerged commits.
|
|
|
|
merge.dialog.customizer.filter.by.conflicted.file.checkbox=Filter by conflicted file
|
|
merge.dialog.customizer.show.details.link.label=Show Details
|
|
merge.dialog.customizer.collecting.details.progress=Collecting Commits Details\u2026
|
|
|
|
branch.worker.could.not.create.tag=Could not create tag {0}{1,choice,0#|1#|2# in {2}}
|
|
|
|
commit.options.sign.off.commit.checkbox=Si&gn-off commit
|
|
commit.options.sign.off.commit.message.line=Adds the following line at the end of the commit message:<br/>Signed-off by: {0}
|
|
commit.options.create.extra.commit.with.file.movements=Create extra commit with file movements
|
|
|
|
show.diff.between.dialog.title=Changes Between {0} and Current Working Tree
|
|
show.diff.between.dialog.no.differences.empty.text=No differences
|
|
show.diff.between.dialog.could.not.load.diff.with.branch.error=Could not load diff with {0}: {1}
|
|
annotations.options.detect.movements.across.files=Detect Movements Across Files
|
|
annotations.options.detect.movements.within.file=Detect Movements Within File
|
|
annotations.options.ignore.whitespaces=Ignore Whitespaces
|
|
annotations.options.group=Options
|
|
progress.title.moving.files=Moving files\u2026
|
|
|
|
editor.promo.commit.text=Commit right from {0} using a commit interface.
|
|
editor.promo.commit.try.link=Try it
|
|
editor.promo.help.link=Learn more
|
|
editor.promo.close.link=Don't show again
|
|
|
|
tracked.branch.fix.dialog.title=Update
|
|
tracked.branch.fix.dialog.ok.button.text=Update
|
|
tracked.branch.fix.dialog.set.as.tracked=Set as tracked branch
|
|
tracked.branch.fix.dialog.branch.placeholder=Specify branch
|
|
tracked.branch.fix.dialog.not.on.branch.title=Git repositories in the Detached Head
|
|
tracked.branch.fix.dialog.not.on.branch.message=The following repositories will be skipped:
|
|
progress.title.enabling.git=Enabling Git\u2026
|
|
progress.title.creating.git.repository=Creating Git repository\u2026
|
|
|
|
action.selected.file.text=Selected {0,choice,1#File|2#Files}
|
|
action.selected.directory.text=Selected {0,choice,1#Directory|2#Directories}
|
|
action.New.Branch.disabled.several.commits.description=Select single commit to create a new branch
|
|
action.New.Branch.disabled.fresh.description=Cannot create new branch in empty repository. Make initial commit first
|
|
|
|
conflicts.type.both.deleted=both deleted
|
|
conflicts.type.both.added=both added
|
|
conflicts.type.both.modified=both modified
|
|
conflicts.type.deleted.by.you=deleted by you
|
|
conflicts.type.deleted.by.them=deleted by them
|
|
conflicts.type.added.by.you=added by you
|
|
conflicts.type.added.by.them=added by them
|
|
conflicts.merge.window.error.title=Cannot Resolve Conflict
|
|
conflicts.merge.window.error.message=Cannot find file for {0}
|
|
conflicts.accept.progress=Resolving {0,choice,1#Conflict|2#Conflicts}
|
|
conflicts.loading.status=Loading merge conflicts\u2026
|
|
conflicts.resolve.action.text=Resolve
|
|
conflicts.accept.theirs.action.text=Accept Theirs
|
|
conflicts.accept.yours.action.text=Accept Yours
|
|
|
|
remotes.dialog.title=Git Remotes
|
|
remotes.dialog.adding.remote=Adding Remote\u2026
|
|
remote.dialog.add.remote=Add Remote
|
|
remotes.dialog.cannot.add.remote.error.message=Cannot add remote {0} ''{1}''
|
|
remotes.dialog.remove.remote.message=Remove {0,choice,1#remote|2#remotes} {1}?
|
|
remotes.dialog.remove.remote.title=Remove {0,choice,1#Remote|2#Remotes}
|
|
remotes.dialog.removing.remote.progress=Removing {0,choice,1#Remote|2#Remotes}\u2026
|
|
remotes.dialog.removing.remote.error.title=Remove {0,choice,1#Remote|2#Remotes}
|
|
remotes.dialog.removing.remote.error.message=Cannot remove {0,choice,1#remote|2#remotes} {1}
|
|
remotes.changing.remote.progress=Changing Remote\u2026
|
|
remotes.changing.remote.error.title=Change Remote
|
|
remotes.changing.remote.error.message=Cannot change remote {0} to {1} ''{2}''
|
|
remotes.operation.not.executed.message=operation was not executed
|
|
remotes.operation.error.message={0} in {1}:\n{2}
|
|
remotes.remote.column.name=Name
|
|
remotes.remote.column.url=URL
|
|
remotes.define.remote=Define Remote
|
|
remotes.define.remote.name=Name:
|
|
remotes.define.remote.url=URL:
|
|
remotes.define.empty.remote.name.validation.message=Remote name cannot be empty
|
|
remotes.define.empty.remote.url.validation.message=Remote URL cannot be empty
|
|
remotes.define.invalid.remote.name.validation.message=Remote name contains illegal characters
|
|
remotes.define.duplicate.remote.name.validation.message=Remote name ''{0}'' is already used
|
|
tab.title.repo.root.name.at.revision={0} at {1}
|
|
tab.title.conflicts=Conflicts
|
|
|
|
button.crlf.fix.dialog.commit.as.is=Commit As Is
|
|
button.crlf.fix.dialog.fix.and.commit=Fix and Commit
|
|
title.crlf.fix.dialog=Line Separators Warning
|
|
text.crlf.fix.dialog.description.warning=You are about to commit CRLF line separators to the Git repository.<br/>It is recommended to set the {0} Git attribute to {1} to avoid line separator issues.
|
|
text.crlf.fix.dialog.description.proposed.fix=If you choose <b>Fix and Commit</b>, {0} will be executed.<br/>If you choose <b>Commit As Is</b>, the config value won''t be changed.
|
|
text.crlf.fix.notification.description.warning=You are about to commit CRLF line separators to the Git repository
|
|
progress.finishing.conflict.resolve=Finishing Resolving Conflicts
|
|
link.label.editor.notification.merge.conflicts.resolve.in.progress=Resolving merge conflicts is in progress
|
|
link.label.merge.conflicts.resolve.in.progress.focus.window=Show resolve conflicts window
|
|
link.label.merge.conflicts.resolve.in.progress.cancel.resolve=Cancel resolve
|
|
link.label.editor.notification.merge.conflicts.suggest.resolve=File has unresolved merge conflicts
|
|
link.label.merge.conflicts.suggest.resolve.show.window=Resolve conflicts\u2026
|
|
label.diff.content.title.submodule.suffix={0} (Submodule)
|
|
error.git.version.check.failed=Error while executing ''git --version''. ExitCode: {0}, errors: {1}
|
|
|
|
local.changes.save.policy.stash=Stash
|
|
local.changes.save.policy.shelve=Shelve
|
|
notification.title.fetch.failure=Fetch failed
|
|
notification.title.fetch.success=Fetch successful
|
|
title.sudo.command.install.git=Install Git
|
|
|
|
error.git.parse.unknown.file.status=Unknown file status: {0}
|
|
error.git.parse.not.a.revision.number=The string ''{0}'' does not represent a revision number
|
|
error.git.repository.not.found=The repository does not exist anymore: {0}
|
|
|
|
title.changes.excluded.from.commit=Changes Excluded from Merge Commit
|
|
label.changes.excluded.from.commit.are.you.sure.want.to.continue=Are you sure you want to exclude these changed files from merge commit?
|
|
button.changes.excluded.from.commit.commit.anyway=Commit Anyway
|
|
title.unresolved.conflicts.pre.commit.check=Unresolved Conflicts
|
|
message.unresolved.conflicts.prevent.commit=Cannot commit changes due to unresolved conflicts.
|
|
|
|
label.user.name=&Name:
|
|
label.user.email=&E-mail:
|
|
checkbox.set.config.property.globally=Set properties &globally
|
|
title.user.name.email.not.specified=Git User Name Is Not Defined
|
|
button.set.name.and.commit.template=Set and {0}
|
|
validation.warning.set.name.email.for.git=You need to specify username and email for Git
|
|
validation.error.email.no.at=The email address must contain the '@' symbol
|
|
label.name.email.not.defined.in.n.roots=Git user.name and user.email properties are not defined in {0,choice,1#root|2#roots}
|
|
error.cant.set.user.name.email=Could not set user.name and user.email
|
|
commit.check.warning.user.name.email.not.set=Git user.name and user.email are not set
|
|
progress.setting.user.name.email=Setting Git user name\u2026
|
|
progress.setting.config.value=Updating Git config\u2026
|
|
progress.checking.line.separator.issues=Checking for line separator issues\u2026
|
|
|
|
commit.check.warning.title.commit.during.rebase=Rebase in progress in the repository: {0}. Committing during rebase may lead to the commit loss.
|
|
commit.check.warning.title.commit.during.rebase.details=More about Git rebase
|
|
warning.title.commit.with.unfinished.rebase=Unfinished Rebase Process
|
|
warning.message.commit.with.unfinished.rebase=The Git repository at the following path has an <b>unfinished rebase</b> process:<br/>{0}<br/>You probably want to <b>continue rebase</b> instead of committing.<br/>Committing during rebase may lead to the commit loss.
|
|
link.label.commit.with.unfinished.rebase.read.more=Read more about Git rebase
|
|
|
|
commit.check.warning.title.commit.with.detached.head=The repository is in the detached HEAD state: {0}
|
|
commit.check.warning.title.commit.with.detached.head.details=More about detached HEAD
|
|
warning.title.commit.with.detached.head=Commit in Detached HEAD
|
|
warning.message.commit.with.detached.head=The Git repository at the following path is in the <b>detached HEAD</b> state:<br/>{0}<br/>You can look around, make experimental changes and commit them, but be sure to checkout a branch not to lose your work.<br/>Otherwise you risk losing your changes.
|
|
link.label.commit.with.detached.head.read.more=Read more about detached HEAD
|
|
|
|
warning.title.commit.with.bad.windows.file.name=File Name Is Not Allowed on Windows
|
|
warning.message.commit.with.bad.windows.file.name.reserved=Some files use reserved names that are not allowed on Windows: ''{0}''.\nIf you commit, it will not be possible to check out the Git repository on Windows.
|
|
warning.message.commit.with.bad.windows.file.name.bad.character=Some of the file names contain characters that are not allowed on Windows: ''{0}''.\nIf you commit, it might not be possible to check out the Git repository on Windows.
|
|
|
|
error.commit.cant.collect.partial.changes=Cannot collect partial changes to commit
|
|
error.commit.cant.commit.multiple.changelists=Cannot commit changes from multiple changelists at once
|
|
error.commit.cant.commit.with.unmerged.paths=Committing is not possible because you have unmerged files.
|
|
error.commit.cant.create.message.file=Creation of commit message file failed
|
|
post.commit.check.load.changes.error=Could not load changes in root {0} for {1}
|
|
|
|
commit.check.warning.title.large.file=You are about to commit a large file into the repository: {0} {0,choice,1#file|2#files} with the total size of {1}MB.\nIt is not recommended to store large files in a Git repository. Consider using Git LFS.
|
|
|
|
label.credential.store.key.http.password=Git HTTP
|
|
error.cannot.delete.file=Cannot delete file: {0}
|
|
action.description.cant.revert.merge.commit=Reverting merge commits is not allowed
|
|
progress.title.reverting.n.commits=Reverting {0,choice,1#commit|2#commits}
|
|
progress.title.validating.revision=Validating Revision\u2026
|
|
|
|
revision.number.cannot.parse.output=Cannot parse the output: [{0}]
|
|
|
|
unexpected.tree.entries.error=Unexpected tree entries: {0}
|
|
unexpected.tree.object.error=Unexpected tree object: {0}
|
|
revert.operation.name=revert
|
|
revert.operation.applied=reverted
|
|
cherry.pick.name=cherry-pick
|
|
cherry.pick.applied=applied
|
|
operation.name.validating.revision.0=validating revision {0}
|
|
operation.name.loading.revision=loading revision
|
|
combobox.item.file.invalid=(invalid)
|
|
warning.your.local.changes.would.be.overwritten.by=Your local changes will be overwritten by {0}.\n\
|
|
Commit, {1}, or revert them to proceed.
|
|
local.changes.would.be.overwritten.by.merge.view.them.action=View them
|
|
dialog.title.local.changes.prevent.from.operation=Local Changes Prevent from {0}
|
|
notification.title.git.operation.failed=Git {0} Failed
|
|
notification.title.untracked.files.prevent.operation=Untracked Files Prevent {0}
|
|
notification.content.untracked.files.prevent.operation.move.or.commit=Move or commit them before {0}<br/>{1}
|
|
dialog.title.could.not.operation=Could not {0}
|
|
dialog.title.untracked.files.preventing.operation=Untracked Files Preventing {0}
|
|
dialog.message.untracked.files.will.be.overwritten.by.operation=These untracked files will be overwritten by {0}
|
|
button.rollback=Rollback
|
|
button.don.t.rollback=Don't Rollback
|
|
progress.title.update=Update
|
|
notification.content.fetched.successfully=Fetched successfully
|
|
notification.content.fetch.failed.couldn.t.authorize=Fetch failed: authorization error
|
|
notification.content.couldn.t.authorize=Authorization error
|
|
notification.title.fetch.failed=Fetch failed
|
|
notification.title.fetch.details=Fetch details
|
|
notification.title.couldn.t.reset.merge=Failed to abort the merge operation
|
|
notification.title.error.merging=Merge Error
|
|
progress.text.merging.repository=Merging{0}\u2026
|
|
dialog.title.rebasing.merge.commits=Rebasing Merge Commits
|
|
dialog.message.rebasing.merge.commits=You are about to rebase a merge commit with conflicts.\n\nChoose 'Merge' if you don't want to resolve conflicts again, or you still can rebase if you want to linearize the history.
|
|
dialog.title.update.branch=Update {0}
|
|
dialog.message.update.branch=You are about to update {0} from {1}.\n\nChoose ''Merge'' if you want to create a merge commit, ''Rebase'' if you want to rebase onto {1}.
|
|
rebasing.merge.commits.button.merge=Merge
|
|
rebasing.merge.commits.button.rebase=Rebase
|
|
rebasing.merge.commits.button.cancel=Cancel
|
|
progress.details.refreshing.files.for.root=Refreshing files for the root {0}
|
|
notification.title.couldnt.collect.updated.files.info=Could not collect the updated files info
|
|
notification.content.couldnt.collect.updated.files.info=Update of {0} was successful, but we could not collect the updated changes because of an error
|
|
notification.title.update.failed=Update failed
|
|
notification.title.can.t.update.no.current.branch=Cannot Update: No Current Branch
|
|
notification.content.detached.state.in.root.checkout.branch=You are in the ''detached HEAD'' state, which means that you''re not on any branch{0}<br/>Checkout a branch to be able to update the project.
|
|
notification.content.branch.in.repo.has.no.tracked.branch={0}{1} has no tracked branch
|
|
notification.title.error.updating.root=Error updating {0}
|
|
notification.content.updating.root.failed.with.error=Update {0} failed with an error: {1}
|
|
git.update.operation=Update
|
|
progress.update.destination.remote=Remote
|
|
action.Git.ShowBranches.text=Show Branches
|
|
action.Git.ShowBranches.pretty.description=Show Branches
|
|
action.Git.Toolbar.ShowMoreActions.text=Version Control
|
|
action.Git.Toolbar.ShowMoreActions.description=VCS Operations
|
|
no.revisions.available=No revisions
|
|
search.everywhere.group.name=Git
|
|
search.everywhere.group.full.name=Git Refs
|
|
search.everywhere.items.commit.by.hash=Commit by hash
|
|
search.everywhere.items.local.branch=Local branch
|
|
search.everywhere.items.remote.branch=Remote branch
|
|
search.everywhere.items.tag=Tag
|
|
search.everywhere.items.commit.by.message=Commit by message
|
|
commit.author.with.committer={0}, via {1}
|
|
|
|
search.scope.project.git.exclude.ignored=Project Files Excluding Git-ignored
|
|
search.scope.project.git.tracked=Project Files Tracked by Git
|
|
|
|
branch.direction.panel.branch.label=Branch:
|
|
branch.direction.panel.save.button=Save
|
|
branch.direction.panel.base.repo.label=Base repository:
|
|
branch.direction.panel.head.repo.label=Head repository:
|
|
branch.direction.panel.select.link=Select\u2026
|
|
branch.direction.panel.warning.push=There is no remote branch for ''{0}''.\nNew remote branch will be created on ''{1}''.
|
|
branch.direction.panel.warning.not.synced=Local branch is not in sync with remote.\n''{0}'' branch will be synced with ''{1}''.
|
|
|
|
|
|
advanced.settings.git=Version Control. Git
|
|
advanced.setting.git.clone.recurse.submodules=Recursively clone submodules in the project
|
|
advanced.setting.git.clone.recurse.submodules.description=When enabled, Checkout from Git calls 'git clone --recurse-submodules', i.e. clones the main repository with all submodules if there are any
|
|
advanced.setting.git.use.push.force.with.lease=Use Safe Force Push
|
|
advanced.setting.git.use.push.force.with.lease.description=Use '--force-with-lease' when calling force push from IDE instead of just '--force'
|
|
advanced.setting.git.update.incoming.outgoing.info=Check for incoming and outgoing commits
|
|
advanced.setting.git.update.incoming.outgoing.info.description=Update branches info that have incoming/outgoing commits in the Branches popup
|
|
advanced.setting.git.read.content.with=Apply content transformation when reading from Git
|
|
advanced.setting.git.read.content.with.description=Use '--filters' or '--textconv' flags for 'git cat-file' command when reading file content from Git
|
|
advanced.setting.git.use.schannel.on.windows=Use Windows certificate store
|
|
advanced.setting.git.use.schannel.on.windows.description=Force Git to use Windows certificate store to verify SSL connections. Works for Git 2.14 and above.
|
|
advanced.setting.git.branch.cleanup.symbol=Branch name cleanup symbol
|
|
advanced.setting.git.branch.cleanup.symbol.description=Symbol that will be used instead prohibited symbols in Git branch names
|
|
git.content.transform.none=None
|
|
git.content.transform.filters=Filters
|
|
git.content.transform.textconv=TextConv
|
|
push.up.to.commit.allowed.progress.title=Checking if it is allowed to push up to selected commit\u2026
|
|
push.up.to.commit.getting.reference.progress.title=Getting commit reference to HEAD\u2026
|
|
|
|
git.toolbar.widget.no.loaded.repo=Git
|
|
git.toolbar.widget.no.repo=Version control
|
|
git.toolbar.widget.no.repo.tooltip=Configure a version control for the project
|
|
group.Vcs.ToolbarWidget.ShareProject.text=Share Project On
|
|
# suppress inspection "UnusedProperty"
|
|
action.Git.Init.Vcs.Toolbar.Widget.text=Create Git Repository\u2026
|
|
|
|
# Git log index data
|
|
group.Git.Log.ShareLogIndexData.text=Shared Git Log Index Data
|
|
vcs.log.use.log.index.data=Use Shared Git Log Index Data
|
|
vcs.log.status.bar.extracting.log.index.data=Extracting Git Log index data\u2026
|
|
vcs.log.status.bar.replacing.log.index.data=Replacing Git Log index data\u2026
|
|
vcs.log.create.archive.with.log.index.data=Dump Git Log Index Data
|
|
vcs.log.archiving.log.index.data=Archiving Git Log index data\u2026
|
|
|
|
MainToolbarQuickActions.Git.Update.text=Update Project\u2026
|
|
MainToolbarQuickActions.Git.Commit.text=Commit\u2026
|
|
MainToolbarQuickActions.Git.Push.text=Push\u2026
|
|
MainToolbarQuickActions.Git.Diff.text=Show Diff\u2026
|
|
MainToolbarQuickActions.Git.History.text=Show History\u2026
|
|
MainToolbarQuickActions.Git.Rollback.text=Rollback\u2026
|
|
group.MainToolbarVCSGroup.text=VCS Group
|
|
MainToolbarQuickActions.vcs.separator=VCS
|
|
|
|
open.in.browser.error=Cannot open in browser
|
|
open.in.browser.getting.revision=Getting Last File Revision
|
|
open.in.browser.getting.revision.error=Cannot retrieve latest revision for file
|
|
progress.title.calculating.commit.messages=Calculating commit messages
|
|
|
|
newUiOnboarding.git.widget.step.header=Git Widget
|
|
newUiOnboarding.git.widget.step.text.with.repo=Switch between branches, create new ones, \
|
|
and access a list of popular Git actions in the popup menu.
|
|
newUiOnboarding.git.widget.step.text.no.repo=Create a Git repository or share your project. \
|
|
Once version control is set up, you can easily switch between branches, create new ones, and access popular Git actions.
|
|
|
|
# {0} is the file extension for the source language, {1} is the file extension for the second language; e.g. '.java -> .kt'
|
|
convert.language.extra.commit.description=Extra commit for .{0} > .{1} renames
|
|
convert.language.extra.commit.commit.message=Rename .{0} to .{1}
|
|
advanced.setting.git.search.everywhere.tab.enabled=Show Git tab in Search Everywhere
|
|
|
|
activity.name.checkout=Git checkout
|
|
activity.name.rebase=Git rebase
|
|
activity.name.reset=Git reset
|
|
activity.name.merge=Git merge
|
|
activity.name.stash=Git stash
|
|
activity.name.unstash=Git unstash
|
|
activity.name.abort.command=Git abort {0}
|
|
activity.name.undo.commit=Git undo commit
|
|
activity.name.cherry.pick=Git cherry-pick
|
|
activity.name.revert=Git revert
|
|
|
|
action.Git.Log.Show.Command.text=Show Git Log for Command
|
|
log.command.empty.text=[<options>] [<revision-range>] [[--] <path>...]
|
|
|
|
action.git.update.force.pushed.branch.text=Update Force-Pushed Branch
|
|
action.git.update.force.pushed.branch.description=Perform update for possible force-pushed current branch. \
|
|
This action may leverage the existing "Update Project" action (e.g., when a local merge commit(s) exists).
|
|
action.git.update.force.pushed.branch.progress=Performing force-pushed branch update\u2026
|
|
action.git.update.force.pushed.branch.success=Update of possible force-pushed branch was successful
|
|
action.git.update.force.pushed.branch.not.all.local.commits.chery.picked=Not all local commits were cherry-picked from {0} branch
|
|
|