openide/plugins/ide-features-trainer/res/messages/LessonsBundle.properties

### README.md strings

readme.welcome.header=Meet the Interactive Feature Trainer
readme.ift.description=This interactive course will guide you through a lot of IDE workflows and use cases. It comes with many helpful \
  action shortcuts. You don''t need to memorize all of them. Instead, try them and take into your service the most useful ones. \
  Since during your everyday work, you might encounter new problems, revisit this course and give other features a second try. \
  Stay tuned for new lessons helping you to be more productive with {0}.
readme.usage.header=How to use the course
readme.toolwindow.description=The `{0}` tool window contains several modules with the corresponding sets of lessons that you can take \
  in any order. When you finish studying a lesson, it will be marked as completed. You can use a completed lesson for your reference \
  or restart it if you want to refresh your knowledge.
readme.experienced.users.remark=Even though a lesson looks familiar to you, give it a try: you may discover helpful examples and unknown \
  shortcuts of the features you actively use!
readme.start.header=Get started
readme.indexing.description=You are likely reading this `README.md` during the learning project initialization. Usually, `indexing` is the \
  most time-consuming operation during project initialization. The IDE will need to collect information about your environment, project\
  {0,choice,1#, libraries|2#}, and construct internal representation. It is needed for fast navigation and search.
readme.navigation.hint=The `{0}` module in this course will show how to use it.
readme.shortcuts.header=Manage shortcuts
readme.shortcuts.problem.description=Some shortcuts in this course may conflict with the system or other application shortcuts. \
  In this case, you can click the problematic shortcut in the text of the lesson. The opened popup will show you the action name and \
  alternative shortcuts. You will be able to apply the action or assign a new shortcut.
readme.bug.tracker.remark=If there is another issue, try to restart the lesson or report the bug in [our bug tracker]({0}).
readme.conclusion.header=Get back to your project
readme.exit.options=To return to the welcome screen, just close the project window. Alternatively, you can select `{0} | {1}` from \
  the main menu. Also, you can use the `{0}` menu to open or create new projects. By default, the `{2}` tool window is hidden. \
  You can open it by selecting `{3} | {4}` from the main menu.
readme.feedback.request=We will appreciate you leaving your feedback about this learning course!

### This file contains strings from lessons.

## Utilities
proceed.to.the.next.step=<callback id="{0}">Click to proceed</callback>
restore.settings.informer=In this lesson, you have changed some IDE settings. \
  <callback id="{0}">Click</callback> if you want to restore the modified options.

###############################################################################
## Common lessons
###############################################################################

## Essential module
essential.module.name=Essentials
essential.module.description=Discover the most essential capabilities of {0}

context.actions.lesson.name=Context actions
context.actions.invoke.intentions.for.warning=<ide/> has hundreds of context-dependent actions that help you transform, improve, and fix \
 your code. Press {1} to invoke {0}.
context.actions.fix.warning=Let''s apply the first quick-fix: {0}.
context.actions.invoke.general.intentions=You can invoke {0} in almost any context. Let''s see what we can do at \
 another caret position. Press {1} again.
context.actions.apply.intention=Let''s apply the {0} action.
context.actions.refactorings.promotion=Note that a lot of useful refactorings are not available via {0}. \
 Go to the {1} module to learn how to invoke and use them.
# Link name to the IDE help
context.actions.help.intention.actions=Intention actions

onboarding.return.to.welcome.remark=\ and return to the Welcome screen

onboarding.finish.title=Congratulations
onboarding.finish.text=You have just completed the <ide/> Onboarding tour.\n\
  Now you can close the Learning project{0}.\n\
  You can also continue your study and try other lessons.
onboarding.finish.exit=Close Demo Project
onboarding.finish.modules=Show More Lessons

## Editor basics module
editor.basics.module.name=Editor basics
editor.basics.module.description=Add, delete, select, move, and duplicate your code with smart shortcuts.

goto.action.lesson.name=Search for actions
goto.action.mac.workaround=If the <strong>Terminal</strong> search opens instead of {0}, refer to <a href="{1}">this article</a>.
goto.action.use.find.action.1=One of the most useful shortcuts is {0}. It allows you to search through all available IDE \
  actions without needing to know their exact names or shortcuts. Try it now with {1}.
goto.action.use.find.action.2=Alternatively, you can press {1} twice to invoke {0}, which helps you find project code entities \
  <strong>and</strong> IDE items. The choice is yours.
goto.action.invoke.about.action=For example, if you want to learn about <ide/>, type {0} and press {1}.
goto.action.to.return.to.the.editor=Press {0} to return to the editor.
goto.action.invoke.again=You can also use {0} or double {1} to change IDE and project settings. Press one of these shortcuts again.
goto.action.show.line.numbers.request=Type {0} to see the {1} selector.
goto.action.first.lines.toggle=Switch the line numbers {0, choice, 0#off|1#on}.
goto.action.second.lines.toggle=Now switch the line numbers back {0, choice, 0#on|1#off}.
goto.action.propose.to.go.next.new.ui=Awesome! Just press {0} or click the button below to start the next lesson.
goto.action.popup.closed.warning.message=Press {0} or press {1} twice to open the search window again.

collapse.lesson.name=Collapse
collapse.try.collapse=Sometimes you need to collapse a piece of code for better readability. Try to collapse a code fragment with {0}.
collapse.hit.expand=To expand a code region, press {0}.
collapse.all.collapse=If you want to collapse all regions in the file, press{0}.
collapse.all.expand=Similarly, press {0} to expand all available regions.
# Link name to the IDE help
collapse.help.link=Expand or collapse code elements

duplicate.and.delete.lines.lesson.name=Duplicate and delete lines
duplicate.and.delete.lines.duplicate.line=Duplicate line at the caret with {0}.
duplicate.and.delete.lines.select.several.lines=You can apply the same action to multiple lines. \
  For example, press {0} twice to select the current and previous line.
duplicate.and.delete.lines.duplicate.several.lines=And now press {0} to duplicate selected lines.
duplicate.and.delete.lines.unexpected.selection.restore=Unexpected selection
duplicate.and.delete.lines.delete.line=To delete the current line, press {0}.

move.lesson.name=Move code fragments
move.pull.down=Rearranging lines usually involves two actions: cut and paste. \
  With <ide/>, you can do it with just one action. Press {0} to pull down the current line.
move.pull.up=Similarly, to pull a line up, press {0}.
move.whole.method.up=Try to move the whole method up with {0}. Note that the caret should be at the header of the method.
move.whole.method.down=Now move it down with {0}.

multiple.selections.lesson.name=Multiple selections
multiple.selections.select.symbol=Press {0} to select the symbol at the caret.
multiple.selections.select.next.symbol=Press {0} again to select the next occurrence of this symbol.
multiple.selections.deselect.symbol=Press {0} to deselect the last occurrence.
multiple.selections.select.all=Press {0} to select all occurrences in the file.
multiple.selections.replace=Type {0} to replace all occurrences of {1} with {0}.
multiple.selections.escape=Press {0} to reset multiple selections and return to the single caret mode.
# Link name to the IDE help
multiple.selections.help.multiple.carets=Multiple carets and selection ranges

selection.lesson.name=Expand and shrink the code selection
selection.select.word=Place the caret before any word. Press {0} to move the caret to the next word and select everything in between.
selection.extend.selection=Press {0} to extend the selection to the next code block.
selection.extend.until.whole.file=Try to increase your selection with {0} until the whole file is selected.
selection.shrink.selection={0} shrinks the selection. Try it.
# Link name to the IDE help
selection.help.select.code.constructs=Select code constructs

new.selection.select.word=Press {0} to select the word under the caret.
new.selection.select.string=Press {0} again to select the whole string.
new.selection.add.quotes=Press {0} for the third time to include quotes in the selection.
new.selection.select.call=Press {0} {1,choice,1#one|2#two|3#three|4#four} more times to select the whole call.
new.selection.unselect=Suppose we actually want to select its arguments instead of the whole call.\
  Press {0} to shrink selection back to the arguments.
new.selection.select.if=We moved the caret to the beginning of the {0} statement. Press {1} two times to select it. \
  A keyword might be a good starting point for choosing the corresponding statement with just a few presses.

comment.line.lesson.name=Comment line
comment.line.comment.any.line=Comment out any line with {0}.
comment.line.uncomment.that.line=Uncomment the commented line with the same shortcut: set the caret anywhere in that line and press {0}.
comment.line.comment.several.lines=Select several lines and then comment them out with {0}.
comment.line.uncomment.several.lines=To uncomment multiple lines, select all commented lines and press {0}.
comment.block.lesson.name=Comment lines and blocks of code
comment.block.comment=To comment with block comment {0}, select a code block and press {1}.
comment.block.uncomment=To uncomment a block comment, set the caret anywhere in the commented block and press {0}.

surround.and.unwrap.lesson.name=Surround and unwrap
surround.with.lesson.name=Surround with
surround.and.unwrap.invoke.surround=Press {0} to surround the selected code fragment with some template code.
surround.and.unwrap.choose.surround.item=Choose {0} item.
surround.and.unwrap.invoke.unwrap=Let''s return to the previous state with the unwrapping action by {0}.
surround.and.unwrap.choose.unwrap.item=Choose the {0} item.
# Link names to the IDE help
surround.and.unwrap.help.surround.code.fragments=Surround code fragments
surround.and.unwrap.help.unwrapping.and.removing.statements=Unwrapping and removing statements

## Completion module
code.completion.module.name=Code completion
code.completion.module.description=Let the IDE complete your code. Try basic, smart, and other types of completion.

basic.completion.lesson.name=Basic completion
basic.completion.start.typing=By default, <ide/> proposes completion for your code instantly. \
  Start typing {0} right where the caret is, and you will see the completion list with matching suggestions.
basic.completion.just.press.to.complete=Now just press {0} to complete this statement.
basic.completion.activate.explicitly=To activate basic completion explicitly, press {0}.
basic.completion.finish.explicit.completion=Select {0} and press {1}.
# Link name to the IDE help
basic.completion.help.code.completion=Basic completion

completion.with.tab.lesson.name=Completion with tab
completion.with.tab.begin.completion=Press {0} to see completion suggestions. If you do not see {1} in the list of suggestions, start typing {1} until you see\
  \ this entry.
completion.with.tab.finish.with.tab=Select {0} and press {1}. \
  This action does not simply insert the selected suggestion but replaces the word at the caret completely.

smart.completion.lesson.name=Type-matching completion

postfix.completion.lesson.name=Postfix completion
postfix.completion.intro=Postfix Completion helps you reduce backward caret jumps as you write code. \
  It lets you transform an already typed expression into another one based on the postfix you add, the type of expression, and its context.
# Link name to the IDE help
postfix.completion.help.link=Postfix code completion

## Refactoring module
refactorings.module.name=Refactorings
refactorings.module.description=Make your code neat with rename, extract, and other types of refactorings.
refactorings.change.settings.warning.message=To complete this lesson, change refactoring options in the editor settings. \
  Press {0}, go to {1} <strong>\u2192</strong> {2}, and select {3} under {4}. \
  Alternatively <callback id="{5}">click</callback> to change the setting.

rename.lesson.name=Rename
# Link name to the IDE help
rename.help.link=Rename refactorings

refactoring.menu.lesson.name=Refactoring menu
refactoring.menu.show.refactoring.list=<ide/> provides a variety of refactorings. Many of them have their own shortcuts, \
  but you can always press {0} to list all refactorings available in the current context.
# Next string does not require translation
refactoring.menu.introduce.parameter.eng=Suppose you need to move the selected expression to the call site and pass it as a parameter of the containing method. \
  {0} can do exactly that. Now simply type <strong>pa</strong> (introduce <strong>pa</strong>rameter) or \
  <strong>ip</strong> (<strong>i</strong>ntroduce <strong>p</strong>arameter) to reduce the proposed list.
refactoring.menu.introduce.parameter=Suppose you need to move the selected expression to the call site and pass it as a parameter of the containing method. \
  Select {0} from the list and press {1}.
refactoring.menu.start.refactoring=Press {0} to start the {1} refactoring. \
  <strong>Note</strong> that you can learn refactoring shortcuts from the refactoring menu.
refactoring.menu.finish.refactoring=To complete the refactoring, choose some name for the new parameter or leave the default one and press {0}.
# Link name to the IDE help
refactoring.menu.help.link=Invoke refactoring

## Code Assistance module
code.assistance.module.name=Code assistance
code.assistance.module.description=Learn how to format your code, obtain parameter info, and preview quick popups.

local.history.lesson.name=Restore removed code
local.history.remove.code=In this lesson, you will learn how to restore code using {0}. Press {1} to delete the selected code fragment.
local.history.file.modification.progress=Modifying file
local.history.editor.hint=File modification is disabled for the current step.
local.history.dialog.message=The IDE simulates the process of editing a file. Please wait until it completes.
local.history.imagine.restore=Imagine you need to restore code that was deleted earlier. {0} won''t work because there have been multiple changes since then and you don''t want to lose those changes.
local.history.invoke.context.menu=Use {0} to restore the deleted code with just a few clicks. Right-click anywhere in the editor to open the context menu.
local.history.show.history=Choose {0} \u2192 {1}.
local.history.select.revision=The left pane of the {0} dialog displays a list of saved revisions of the current file. The project state is automatically saved in {1} every time you edit code, run tests, or perform other actions. Let''s select the revision that is highlighted.
local.history.restore.code=The right pane displays the differences between the selected and current revisions of the file. In this case, the selected revision contains the code that was deleted earlier. To restore the code fragment, click the chevron button {0}.
local.history.restore.code.balloon=Click to restore the code fragment
local.history.close.window=Close the dialog to return to the changed code. Press {0}.
local.history.congratulations=Great! You have restored your code fragment!
# Link name to the IDE help
local.history.help.link=Local History

code.format.lesson.name=Code format
code.format.reformat.selection=<ide/> can help you correct code formatting with just one action. \
Press {0} to reformat the selected code fragment.
code.format.reformat.file=To reformat the whole file when no lines are selected, use {0}.
code.format.show.reformat.file.dialog=Use {0} to show reformat settings.
code.format.optimize.imports=Here you can configure reformat options. For example, switch {0} on and click {1}.
# Link name to the IDE help
code.format.help.link=Configuring code style

parameter.info.lesson.name=Parameter info
parameter.info.use.action=The {0} popup shows the names of parameters in method and function calls. \
  <ide/> automatically shows a popup with all available method signatures within a second after you type an opening bracket in the editor, \
  or select a method from the suggestion list. Press {1} to see the method''s signature.
parameter.info.add.parameters=Use a width of {0} and a height of {1}.
# Link name to the IDE help
parameter.info.help.link=Parameter info

quick.popups.lesson.name=Quick popups
quick.popups.show.documentation=You can get quick information for any symbol right from the editor by means of the {0} feature. \
  Press {1} to see the documentation for the symbol at the caret.
quick.popups.close=Press {0} to close the popup.
quick.popups.press.show.documentation.again=Press {0} again to open this documentation in the Documentation tool window.
quick.popups.press.show.documentation.focus=Click over Documentation tool view or press {0} one more time to move focus there.
quick.popups.show.implementation=Press {0} to see the definition of the symbol at the caret.
# Link name to the IDE help
quick.popups.help.link=Quick popups

editor.coding.assistance.lesson.name=Editor coding assistance
editor.coding.assistance.goto.next.error=Press {0} to go to the next highlighted error in the file.
editor.coding.assistance.fix.error=Let''s fix this error. Press {0} and select {1}.
editor.coding.assistance.goto.next.warning=Let''s go to the next warning. Press {0}.
editor.coding.assistance.show.warning.description=Press {0} to expand the warning description.
editor.coding.assistance.fix.warning=The popup shows a refactoring action suggestion to fix this warning.
editor.coding.assistance.highlight.usages=Another useful tool is the usages highlighting. \
  Press {0} to highlight all usages of the symbol at the caret within the file.
# Link name to the IDE help
editor.coding.assistance.help.link=Work with source code

## Navigation module
navigation.module.name=Navigation
navigation.module.description=Jump to source, navigate to declarations, implementations, and a file structure.

declaration.and.usages.lesson.name=Declaration and usages
declaration.and.usages.jump.to.declaration=Press {0} to jump to the declaration of a method.
declaration.and.usages.show.usages=Now the caret is at the method''s declaration. \
  Use the same shortcut {0} to see all of its usages, then select one of them.
declaration.and.usages.find.usages=Press {0} to see a more detailed view of usages. You can invoke {0} on either a declaration or a usage.
declaration.and.usages.pin.motivation=From the {0} view you can navigate both to usages and declarations.   The next search will override these results in the {0} view. To prevent it, pin the results.
declaration.and.usages.right.click.tab=To pin the tab, right-click the highlighted tab title.
declaration.and.usages.select.pin.item=Select {0}.
declaration.and.usages.hide.view=When you have finished browsing usages, press {0} to hide the view.
declaration.and.usages.open.find.view=Press {0} to open the {1} view again.
# Link name to the IDE help
declaration.and.usages.help.link=Go to declaration and its type

find.occurrences.lesson.name=Next/previous occurrence
find.occurrences.invoke.find=In this lesson, you selected {0}. Press {1} to start a full-text search through the current file.
find.occurrences.find.previous=To jump to the previous occurrence, press {0}.
find.occurrences.search.closed.warning=Press {0} to open the search field again.
find.occurrences.find.next=<ide/> automatically copies the selected text into the search field. Let''s find the next occurrence. \
  Press {0} or {1}.
find.occurrences.close.search.tool=With the search panel closed, you can still use these shortcuts to navigate between \
  the recently found occurrences. Let''s close the search panel by pressing {0}.
find.occurrences.find.next.in.editor=Locate the next occurrence with {0}.
find.occurrences.find.previous.in.editor=And {0} to go backwards.
find.occurrences.note.about.cyclic=<strong>Note:</strong> The search is cyclic. When you press {0} twice at the last occurrence, \
  the first occurrence will be selected. {1} is cyclic too.
# Link name to the IDE help
find.help.link=Search for a target within a file

file.structure.lesson.name=File structure
file.structure.open.popup=A large source file can be difficult to read and navigate. Sometimes you only need to preview it. \
  Press {0} to open the file structure.
file.structure.request.prefixes=Suppose you want to find a method with {0} and {1} words in its name. \
  Type {2} (prefixes of the required words) to filter the file structure.
file.structure.navigate=Only one item remains. Now press {0} to jump to the selected item.
file.structure.toolwindow=<ide/> can also show you the file structure as a tool window. Open it with {0}.
# Link name to the IDE help
file.structure.help.link=View source file structure

recent.files.lesson.name=Recent files and locations
recent.files.first.transition=Wondering how the {0} method is implemented? Let''s go to its declaration using {1}.
recent.files.dialog.message=We want to simulate a basic workflow: quick navigation between files. \
  Please wait until it completes.
recent.files.dialog.title=Workflow Simulation
recent.files.progress.title=Opening files
recent.files.show.recent.files=We dived deeply into the library files. How can we get back to our file? <ide/> has a feature that can help us \
  show recently opened files. Press {0}.
recent.files.search.typing=You can search the file by its name. Type {0} (prefixes of the required words).
recent.files.search.jump=Only one file remains. Now press {0} to jump to the selected file.
recent.files.use.recent.files.again=We are back to our file. But let''s view the recent files again by using {0}.
recent.files.delete=This list contains many source files that we don''t want to open anymore. Let''s delete {0} files from \
  our recent files history by using {1}.
recent.files.close.popup=Now the history of our recent files is cleaner. Click somewhere outside the popup to close it or use {0}.
recent.files.show.recent.locations=With another useful action, you can discover your code in the recently visited files. Press {0}
recent.files.locations.search.typing=Here you can search by code fragments that you remember. Type {0}
recent.files.locations.search.jump=Now select the highlighted fragment and press {0} to open the containing file.
# Link name to the IDE help
recent.files.locations.help.link=Find recent files

search.everywhere.lesson.name=Search everywhere
search.everywhere.invoke.search.everywhere=Press {1} twice to open {0}.
search.everywhere.type.prefixes=Suppose you are looking for some code definition with the words {0} and {1} in the name. \
  Type {2} (initial letters of these words) in the search field.
search.everywhere.navigate.to.class=Select {0} with the keyboard arrows and press {1} to jump to the found definition.
search.everywhere.goto.class=Great! However, sometimes you need to find only classes or search only in some specific directories. \
  Use {0} to search for classes.
search.everywhere.type.class.name=Suppose you need some library class responsible for buffered reading from an input stream. \
  Type {0} (initial letters of the search words), but do not navigate yet.
search.everywhere.use.all.places=Now you can see there is a matching class in the demo project. However, we need to find a class in libraries. \
  Let''s switch the {0} filter to {1} to bring up matching classes from available libraries.
search.everywhere.class.popup.closed.warning.message=Press {0} to open the search window again.
search.everywhere.quick.documentation=Press {0} to preview documentation for the selected class.
search.everywhere.close.documentation.popup=Press {0} to close the popup.
search.everywhere.finish=<strong>Done!</strong> Similarly, you can press {0} to look for a method or global variable and {1} \
  to look for a file.
search.everywhere.navigation.promotion=You will find other navigation actions and workflow use cases in the {0} module.

find.in.files.lesson.name=Find and replace in files
find.in.files.show.find.popup=Suppose you want to find all occurrences of some string in the project. Press {0} to open the {1} window.
find.in.files.type.to.find=Type {0} to search for all textual occurrences in the Learning project.
find.in.files.whole.words=You were supposed to find the {0} string but also got some {1} entries. \
  Let''s narrow down the search to a whole word. Click {2} or press {3}.
find.in.files.select.row=You can see the context of the found string in the embedded editor. \
  Click the highlighted row or navigate to it by using {0} and {1} buttons.
find.in.files.go.to.file=Also, you can open the selected file in the main editor. Press {0} or double-click the highlighted item to move to the corresponding file.
find.in.files.show.replace.popup=Suppose you want to replace all found occurrences with another string. \
  It may be very boring to perform replacing in each file sequentially. <ide/> will help you with this task. Press {0} to open {1} window.
find.in.files.type.to.replace=Let''s replace all occurrences of {0} with {1}. Type {1} in the highlighted field.
find.in.files.select.directory=You can define the scope of search and replace. \
  Click the {0} button or press {1} to narrow the replacement only to current directory.
find.in.files.press.replace.all=Click {0} to start the replacement.
find.in.files.confirm.replace=Finally, click {0} in the dialog to confirm.
find.in.files.popup.closed.warning.message=Press {0} to open the {1} window again.
# Link name to the IDE help
find.in.files.help.link=Find and replace text in project files

extract.method.lesson.name=Extract method
extract.method.invoke.action=Press {0} to extract the selected code block into a method.
extract.method.start.refactoring=Click {0} to start refactoring.
extract.method.confirm.several.replaces=Cocktail sort has two swap places. The first fragment has just been extracted. \
  Click {0} to extract both of them.
extract.method.second.fragment=Now you can confirm or reject the replacement of the second fragment.
# Link name to the IDE help
extract.method.help.link=Extract method

extract.variable.lesson.name=Extract variable
extract.variable.start.refactoring=Press {0} to extract a local variable from the {1} expression.
extract.variable.replace.all=This code block contains 3 occurrences of the selected expression. \
  Choose the second item on the list to replace all of them.
extract.variable.choose.name=Choose a name for the new variable or leave it as it is. Press {0} to complete the refactoring.
# Link name to the IDE help
extract.variable.help.link=Extract/Introduce variable

## Run/Debug module
run.debug.module.name=Run and debug
run.debug.module.description=Run your code and fix errors with the IDE visual debugger.

run.configuration.lesson.name=Run configuration
run.configuration.run.current=Let''s run this demo program by clicking {0} on the toolbar.
run.configuration.run.current.balloon=Let's run this sample
run.configuration.no.run.configuration=As you can see, running {0} does not create any run configurations.
run.configuration.temporary.to.permanent=Now <ide/> has created a temporary run configuration. \
  Temporary configurations are automatically deleted when their number exceeds the default limit of five. \
  Let''s convert the temporary configuration into a permanent one. Click {0} next to the Run and Debug buttons.
run.configuration.open.additional.menu.balloon=Show more actions
run.configuration.select.save.configuration=Select {0}.
run.configuration.open.run.configurations.popup=Now let's look at the run configurations popup. Click the drop-down.
run.configuration.hover.generated.configuration=For this lesson we added another configuration with parameters. \
  Hover the mouse over this configuration to see the Run or Debug buttons for it.
run.configuration.run.generated.configuration=Let's run it.
run.configuration.edit.configuration=To edit run configurations or add new ones, \
  click the drop-down while holding {0} or open the drop-down and click {1}.
run.configuration.settings.description=This is a place for managing all run configurations. \
  Here you can set program parameters, JVM arguments, environment variables, and so on.
run.configuration.tip.about.save.configuration.into.file=Tip: To make a run configuration accessible to your colleagues, \
  store it as a separate file and share this file via a version control system.
run.configuration.close.settings=Now close the dialog to finish this lesson.
# Link name to the IDE help
run.configuration.help.link=Run/debug configurations

debug.workflow.lesson.name=Debug workflow
debug.workflow.frames.disabled.warning=To continue this lesson, <callback id="{0}">enable</callback> {1} view in the Debug tool window.
debug.workflow.incorrect.breakpoints=Breakpoints are set incorrectly for this lesson.
debug.workflow.run.current=Let's run this sample program that calculates the average amount of different fruit from the input.
debug.workflow.exception.description=The program throws an exception, and you can see its stack trace in the Run window. \
  Note that you can click file names and line numbers in the stack trace to navigate to the editor.
debug.workflow.toggle.breakpoint=Let''s set a breakpoint to start investigating the problem. \
  To do so, click the gutter at the desired line or set the caret to that line and press {0}.
debug.workflow.start.debug=To start debugging with the currently selected run configuration, click {0} on the toolbar or press {1}.
debug.workflow.need.restart.lesson=The debug session has been stopped. Restart the lesson.
debug.workflow.use.watches=Indeed, this expression results in an exception. Let''s add this expression to {0} so that it evaluates automatically in the future. \
  Press {1} or click {2}.
debug.workflow.use.watches.shortcut=Alternatively, you can use action {0} to add the selected text to {1} {2}.
debug.workflow.consider.to.add.a.shortcut=(consider assigning a shortcut for it later)
debug.workflow.step.into=To find out what caused the exception, let''s step into the selected call. Pres {0} or click {1} in the Debug window.
debug.workflow.choose.method.to.step.in=Note that there are several nested calls, and Smart Step Into highlights all of them. \
  Press {1} to choose the {0} call and then press {2} to step into it.
debug.workflow.quick.evaluate=Let''s see what we are going to pass to {0}. Press {1} to invoke Quick Evaluate Expression for the selected argument.
debug.workflow.fix.error=Oh, there is a mistake in the array index! Let''s fix it right now. Press {0} to close the popup, and then change 0 to 1.
debug.workflow.step.over=Let''s check whether calling {0} will throw an exception after our fix. To step over the call, press {1} or click {2} in the Debug window.
debug.workflow.mute.breakpoints=Oops, our breakpoint is hit again, but we don''t have to stop here this time. \
  Let''s mute breakpoints by clicking {0} in the Debug window.
debug.workflow.run.to.cursor.intro=Finally, let''s check the result of {0} (for your convenience we''ve moved the caret to its {1} statement).
debug.workflow.run.to.cursor.press=Press {0} to execute the program up to the line where the caret is.
debug.workflow.run.to.cursor.alternative=Alternatively, hover the left-side area and click the inlay {0} action.
debug.workflow.run.to.cursor.note=Note that {0} works even if breakpoints are muted.
debug.workflow.evaluate.expression=To check whether a function throws an exception, you can evaluate an expression that calls this function. \
  Let's copy the selected expression and paste it into the highlighted field in the Debug window.
debug.workflow.evaluate.it=Press {0} to evaluate the expression.
debug.workflow.check.result=Press {0} to evaluate the selected return statement.
debug.workflow.stop.debug=The result is correct! Let''s finish debugging by pressing {0} or clicking {1} on the toolbar.
debug.workflow.resume=The call works without exceptions now. Press {0} or click {1} in the Debug window to resume program execution.
# Link name to the IDE help
debug.workflow.help.link=Debug code


# Link names to the IDE help
help.search.everywhere=Search Everywhere
help.lines.of.code=Lines of code
help.code.completion=Code completion
help.code.comment=Comment and uncomment code
help.code.duplicate=Duplicate line or selection
help.find.actions=Find actions and settings