#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla Public License Version
# 1.1 (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
# http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS IS" basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
# for the specific language governing rights and limitations under the
# License.
#
# The Original Code is The JavaScript Debugger.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 1998
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Robert Ginda, <rginda@netscape.com>, original author
#
# Alternatively, the contents of this file may be used under the terms of
# either the GNU General Public License Version 2 or later (the "GPL"), or
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the MPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****

# NOTE ON LEADING/TRAILING SPACES AND QUOTES...
# Strings in this file are stripped of leading and trailing qoutes, if they are
# present.  This allows you to express leading and trailing whitespace, which
# would otherwise be trimmed by the stringbundle code.  In order to express
# a leading or trailing quote, use two of them.
#
# For example...
#
# my.message1 = "          foo"
# my.message2 = "          foo
#  Both of these produce 10 spaces, followed by the word ``foo''.
# my.message3 = "foo          "
# my.message3 = foo          "
#  Both of these produce the word ``foo'', followed by 10 spaces.
# my.message4 = A sphincter says, "what?""
# my.message4 = "A sphincter says, "what?""
#  Both of these produce the phrase ``A sphincter says "what?"''
#

# character set to convert unicode messages to before writing them to a
# profile report, or generated help text.
msg.report.charset = utf-8
msg.locale.version = 0.9.83
msn.bad.locale     = This version of Venkman is meant to work with a ``%1$S'' locale, but you are currently using a locale marked ``%2$S''.  Chances are, you're going to have problems.  Please change to the default locale, or upgrade your language pack.

msg.release.url = http://www.mozilla.org/releases/

## exception descriptions ##
err.notimplemented = Not implemented
err.required.param = Missing required parameter %1$S
err.invalid.param  = Invalid value for parameter %1$S (%2$S)
# 1 url, 2 fileName, 3 lineNumber, 4 reason
err.subscript.load = Error loading subscript from <%1$S>.
err.no.debugger    = JS Debugger Service is not installed.
err.failure        = Operation Failed: %1$S
err.no.stack       = No Stack

## error messages ##
msn.err.unknown.reason  = Unknown reason
msn.err.required.param  = Missing required parameter %1$S
msn.err.invalid.param   = Invalid value for parameter %1$S (%2$S)
msn.err.invalid.pref    = Invalid value for preference %1$S (%2$S)
msn.err.scriptload      = Error loading subscript from <%1$S>.
msn.err.no.source       = No scripts loaded match ``%1$S''.
msn.err.no.command      = No command named ``%1$S''.
msn.err.no.such.view    = No such view ``%1$S''.
msg.err.no.stack        = No stack
msg.err.no.eval.object  = No object selected for evaluations
msn.err.noscript        = No debuggable scripts found for ``%1$S''
msn.err.disabled        = Sorry, ``%1$S'' is currently disabled
msn.err.notimplemented  = Sorry, ``%1$S'' has not been implemented
msn.err.ambigcommand    = Ambiguous command, ``%1$S'', %2$S commands match [%3$S]
msn.err.bp.noline       = No scripts matching <%1$S> contain executable code at line %2$S
msn.err.bp.nodice       = No breakpoint set at <%1$S> line %2$S
msn.err.startup         = An exception occurred while initializing, please file a bug.\n%1$S
msn.err.cant.match      = Error loading template: Can't match ``%1$S''.
msg.err.internal.bpt    = Internal error handling breakpoint.
msn.err.internal.hook   = Internal error processing hook ``%1$S''.
msn.err.failure         = Operation Failed: %1$S
msn.err.no.section      = Missing section before ``%1$S'' in <%2$S>.
msn.err.no.template     = No pref for template named ``%1$S''.
msn.err.internal.dispatch  = Internal error dispatching command ``%1$S''.
msn.err.source.load.failed = Error loading URL <%1$S>: %2$S.
msn.err.no.such.container  = No such container ``%1$S''.
msg.err.condition.failed   = Error evaluating breakpoint condition.
msg.err.format.not.available = Source not available in requested format.
msn.err.no.function     = Line %1$S in <%2$S> is not part of an executable function.
msn.jsdurl.errpage = <html><head><title>Error</title></head><body>Error loading &lt;<b>%1$S</b>&gt;<br>%2$S</body></html>
msg.err.jsdurl.parse     = Error parsing URL.
msg.err.jsdurl.nosource  = URL has no textual source.
msg.err.jsdurl.noservice = No such service.
msg.err.jsdurl.search    = Error in search pattern.
msg.err.jsdurl.sourcetext = Error locating source text.
msn.err.jsdurl.template  = Error loading template named ``%1$S''.
msn.err.meta.failed      = Error processing meta comment ``%1$S'' in <%2$S>, line %3$S.
msg.err.this.not.object  = Result of expression must be an object.
msn.err.unknown.pref     = Unknown pref name ``%1$S''.

## "values" ##
msg.val.unknown     = <unknown>
msg.val.console     = x-jsd:interactive-session
msg.val.na          = <not-available>
msg.val.none         = <none>
msg.val.object      = <object>
msg.val.expression  = <expression>
msg.val.proto       = [[Prototype]]
msg.val.parent      = [[Parent]]

## words ##
msg.val.min         = min
msg.val.max         = max
msg.val.this        = this
msg.val.breakpoint  = breakpoint
msg.val.debug       = error handler
msg.val.debugger    = debugger keyword
msg.val.throw       = thrown exception
msg.val.global      = global
msg.val.scope       = scope
msg.val.exception   = exception
msg.val.on          = on
msg.val.off         = off
msg.val.tlscript    = __toplevel__
msg.val.toscript    = [TimeoutScript]
msg.val.ivscript    = [IntervalScript]
msg.val.evscript    = [EvalScript]
msg.url.native      = x-jsd:native-code

## types ##
msg.type.int        = integer
msg.type.boolean    = boolean
msg.type.double     = double
msg.type.function   = function
msg.type.null       = null
msg.type.object     = object
msg.type.string     = string
msg.type.unknown    = unknown
msg.type.void       = void

msg.class.xpcobj       = XPComponent
msg.class.const.xpcobj = const XPComponent
msg.class.native.fun   = Native Function
msg.class.script.fun   = Script Function

## messages ##
msg.query.close      = Debugging in progress, close anyway?
msg.status.default   = Welcome to the JavaScript Debugger
msn.status.loading   = Loading source for ``%1$S''
msn.status.marking   = Marking source for ``%1$S''
msn.status.stopped   = Stopped in %1$S, %2$S
msn.floater.title    = JSD: %1$S

msg.alert   = Alert
msg.prompt  = Prompt
msg.confirm = Confirm

msg.cant.pprint      = Unable to Pretty Print this function.

msg.slash.required   = THINGS HAVE CHANGED: By default, all commands now start with a forward-slash ('/') character.  Any text that DOES NOT start with a forward-slash will be passed to the ``eval'' command.  For example, to execute the ``step'' command, type ``/step''.  To evaluate ``1 + 1'', you just need to type ``1 + 1''.  If you prefer the previous behavior, type ``/pref sessionView.requireSlash false''.

msg.commasp          = , "
msn.eval.in          = %1$S: %2$S"
msn.stop             = Stopped for %1$S.
msn.cont             = Continuing from %1$S.
msn.subscript.loaded = Subscript <%1$S> loaded with result ``%2$S''.
# 1 exception name, 2 fileName, 3 lineNumber
msn.eval.error       = %1$S: <%2$S>, line %3$S
msn.eval.threw       = Caught exception: ``%1$S''
msg.hello            = Welcome to ``Venkman'', the JavaScript debugger.  Please read the FAQ at <http://www.hacksrus.com/~ginda/venkman/faq/venkman-faq.html>.  Visit the Venkman homepage <http://www.mozilla.org/projects/venkman/> for more information.
msn.version          = You are running Venkman version %1$S.
msn.tip1.help        = Use ``%1$Shelp <command-name>'' for help on specific commands.
msg.tip2.help        = Visit <x-jsd:help> for a searchable command reference.
msg.tip3.help        = Commands start with a forward-slash ('/') character.  Any text that DOES NOT start with a forward-slash will be evaluated as JavaScript.  For example, to execute the ``step'' command, type ``/step''.  To evaluate ``1 + 1'', just type ``1 + 1''.
msg.no.breaks.set    = No breakpoints set.
msg.no.fbreaks.set   = No future breakpoints set.
msg.no.watches.set   = No watches set.
msn.no.properties     = %1$S has no properties.
msn.no.cmdmatch      = No commands match ``%1$S''.
msn.cmdmatch         = Commands matching ``%1$S'' are [%2$S].
msn.cmdmatch.all     = Implemented commands are %1$S.
msn.props.header     = Properties of %1$S in debug target scope:
msn.propsd.header    = Properties of %1$S in debugger scope:
msn.bp.header        = %1$S breakpoints set:
# 1 index, 2 file name, 3 line
msn.bp.line          = #%1$S <%2$S> line %3$S
msn.bp.created       = Breakpoint at <%1$S> line %2$S created
msn.bp.cleared       = Breakpoint at <%1$S> line %2$S deleted
msn.bp.exists        = Breakpoint at <%1$S> line %2$S already set.
msn.watch.header     = %1$S watches set:
msn.enter.expression = Enter expression for new value of \u201c%1$S\u201d:

# 1 index, 2 file name, 3 line
msn.fbp.line         = #%1$S <%2$S> line %3$S
msn.fbp.created      = Future breakpoint at <%1$S> line %2$S created.
msn.fbp.cleared      = Future breakpoint at <%1$S> line %2$S cleared.
msn.fbp.exists       = Future breakpoint at <%1$S> line %2$S already set.
msn.source.line      = %1$S: %2$S"
msg.emode.ignore     = Errors will now be ignored.
msg.emode.trace      = Errors will now be traced.
msg.emode.break      = Errors will now stop the debug target.
msg.tmode.ignore     = Exceptions will now be ignored.
msg.tmode.trace      = Exceptions will now be traced.
msg.tmode.break      = Exceptions will now stop the debug target.
msn.iasmode          = Initialize at Startup is now %1$S.
msn.layout.list      = The following layouts have already been saved [%1$S].  Use ``save-layout <name>'' to save the current layout, or ``restore-layout <name>'' to restore a specific layout.
msn.chrome.filter    = Chrome filtering is now %1$S.
# 1 value, 2 frame
msn.exception.trace  = Exception ``%1$S'' thrown from %2$S.
# 1 message, 2 flags, 3 file, 4 line, 5 pos
msn.erpt.error       = Error ``%1$S'' [%2$S] in file ``%3$S'', line %4$S, character %5$S.
msn.erpt.warn        = Warning ``%1$S'' [%2$S] in file ``%3$S'', line %4$S, character %5$S.
msn.profile.lost     = Lost profile data for script %1$S.
msn.profile.state    = Profile data collection is now %1$S.
msn.profile.saved    = Profile data saved to <%1$S>.
msg.profile.cleared  = Profile data cleared.
msn.profile.saving   = Generating profile report, file %1$S of %2$S
msg.open.file        = Open File...
msg.save.file        = Save As...
msg.open.url         = Enter a URL to Load...
msg.save.profile     = Save Profile Data As...
msg.save.source      = Save Source As...
msg.navigator.xul    = Navigator Window
msg.enter.watch      = Enter expression to watch:

## property value flags ##
msg.vf.enumerable = e
msg.vf.readonly   = r
msg.vf.permanent  = p
msg.vf.alias      = A
msg.vf.argument   = a
msg.vf.variable   = v
msg.vf.error      = E
msg.vf.exception  = X
msg.vf.hinted     = h

## formatting ##

# 1: argument name, 2: value
msn.fmt.argument = %1$S=%2$S"
# 1: property flags, 2: property name, 3: property value
msn.fmt.property = [%1$S] %2$S = %3$S"
# 1: function name, 2: filename
msn.fmt.script = function %1$S in <%2$S>
# 1: function name, 2: arguments, 3: filename, 4: line number
msn.fmt.frame = function %1$S(%2$S) in <%3$S> line %4$S
# 1: type, 2: class name, 3: value
msn.fmt.value.long = [%1$S] [class: %2$S] %3$S"
# 1: type, 2: value
msn.fmt.value.med  = [%1$S] %2$S"
# 1: type, 2: value
msn.fmt.value.short = %1$S:%2$S"
# 1: property count
msn.fmt.object = %1$S properties
# 1: ctor name, 2: property count
msn.fmt.object.value = {%1$S:%2$S}
# 1: JS exception name, 2: error text, 3: file name, 4: line number
msn.fmt.jsexception = %1$S: %2$S @ <%3$S> %4$S"
# 1: error number,  2: error text, 3: file name, 4: line number, 5: function name
msn.fmt.badmojo = BadMojo %1$S: %2$S @ <%3$S> line %4$S (%5$S)
# 1: var number, 2: value
msn.fmt.tmp.assign = $[%1$S] = %2$S"
# 1: string length
msn.fmt.longstr = %1$S characters
# 1: command name 2: parameters
msn.fmt.usage = %1$S %2$S
# 1: function name
msn.fmt.guessedname = [%1$S]
# 1: program counter
msn.fmt.pc = [%1$S]
# 1: pref name 2: value
msn.fmt.prefvalue = Preference ``%1$S'' is ``%2$S''
# 1: index, 2: label, 3: value
msn.fmt.watch.item = %1$S: %2$S = %3$S"
# 1: on|off
msn.fmt.pprint = Pretty Print is %1$S.
# 1: frame number, 2: frame string
msn.fmt.frame.line = #%1$S: %2$S"
# 1: file name, 2: line number, 3: pc
msn.fmt.frame.location = %1$S, line %2$S, pc %3$S
# 1: function name, 2: start line, 3: end line, 4: call count, 5: recurse,
# 6: total, 7: min, 8: max, 9: avg
msn.fmt.profile.str = %1$S: %2$S-%3$S, %4$S call(s)%5$S, %6$Sms total, %7$Sms min, %8$Sms max, %9$Sms avg, excluding calls: %10$S
msn.fmt.profile.str2 = %1$Sms total, %2$Sms min, %3$Sms max, %4$Sms avg
# 1: max recurse depth
msn.fmt.profile.recurse = " (max depth %1$S)

## menu headings ##
msg.mnu.file = &File
msg.mnu.debug = &Debug
msg.mnu.profile = &Profile
msg.mnu.view  = &View
msg.mnu.help  = &Help
msg.mnu.emode = &Error Trigger
msg.mnu.tmode = Throw Tri&gger
msg.mnu.showhide  = Sho&w/Hide
msg.mnu.session.colors = Interactive Session Co&lors
msg.mnu.scripts.instance = F&ile Options
msg.mnu.scripts.wrapper  = Func&tion Options

msn.sourceheader.url   = <%1$S> Line %2$S
msn.default.alias.help = This command is an alias for |%1$S|.

msn.launch.count      = Recorded local startup %1$S, global %2$S.
msg.no.help           = Help not available.
msn.extra.params      = Extra parameters ``%1$S'' ignored.
msg.files.rec         = Files
#msg.doc.consolehdr   = Console Commands
#msg.doc.menuhdr      = Menus
#msg.doc.popuphdr     = Popups
#msg.doc.keyhdr       = Keys

msg.note.console     = This command is available from the console.
msg.note.noconsole    = This command is NOT available from the console.
msg.note.needstack   = You must be stopped at a breakpoint to use this command.
msg.note.nostack     = You CANNOT be stopped at a breakpoint to use this command.
msn.doc.commandlabel = "     Command Name: ``%1$S'' (%2$S)
msn.doc.key          = "Keyboard Shortcut: %1$S
msn.doc.syntax       = "           Syntax: %1$S %2$S
msg.doc.notes        = Notes:
msg.doc.description  = Description:

msn.session.css   = Interactive Session now using CSS from <%1$S>.
msn.session.title = Interactive Session [context: %1$S, scope: %2$S]

msg.source2.help = Please select a source file to display.
msg.margin.break     = " B "
msg.margin.fbreak    = " F "
msg.margin.breakable = " - "
msg.margin.none      = "   "

msg.bpprops.title    = Breakpoint Properties
msg.bpprops.enabled  = Enable breakpoint
msg.fbpprops.title   = Future Breakpoint Properties
msg.fbpprops.enabled = Enable future breakpoint

# view captions
msg.view.breaks  = Breakpoints
msg.view.stack   = Call Stack
msg.view.session = Interactive Session
msg.view.locals  = Local Variables
msg.view.scripts = Loaded Scripts
msg.view.windows = Open Windows
msg.view.source  = Source Code
msg.view.source2 = Source Code
msg.view.watches = Watches

# settings file return values
msg.breakpoints.restored = Breakpoints restored.
msg.watches.restored = Watches restored.
msg.settings.restored = Breakpoints and watches restored.

###################### DO NO LOCALIZE THE *.params STRINGS ######################

## hooks ##

cmd.hook-break-clear.params = <break-wrapper>
cmd.hook-break-clear.help   = Called when a breakpoint instance is cleared.

cmd.hook-break-set.params = <break-wrapper>
cmd.hook-break-set.help   = Called when a breakpoint instance is set.

cmd.hook-debug-stop.help = Called when the debugger stops execution of the debug target.

cmd.hook-debug-continue.help = Called when the debugger continues execution of the debug target.

cmd.hook-display-sourcetext.params = <source-text> [<target-line> [<details>]]
cmd.hook-display-sourcetext.help   = Called when the source text object <source-text> should be presented to the user.  <target-line> is the line which should appear at or near the top of the display.  If <details> is provided, it will be an object representing details about where the <source-text> object was derived from.

cmd.hook-display-sourcetext-soft.params = <source-text> [<target-line> [<details>]]
cmd.hook-display-sourcetext-soft.help   = Functions the same as |hook-display-sourcetext|, except the display should not be scrolled if <target-line> is already visible.

cmd.hook-eval-done.help = Called when an expression is evaluated.

cmd.hook-fbreak-clear.params = <fbreak>
cmd.hook-fbreak-clear.help   = Called when a breakpoint instace is cleared.

cmd.hook-fbreak-set.params = <fbreak>
cmd.hook-fbreak-set.help   = Called when a breakpoint instace is set.

cmd.hook-guess-complete.params = <script-instance>
cmd.hook-guess-complete.help   = Called when function name guessing has completed for the script instance <script-instance>.

cmd.hook-session-display.params = <message> <msgtype>
cmd.hook-session-display.help   = Called when a message should be appended to the interactive session display.  <message> is the message as a string, or DOM node, <msgtype> is the message's type code.

cmd.hook-script-manager-created.params = <script-manager>
cmd.hook-script-manager-created.help   = Called when a new script manager is created.  Script managers delegate commands to one or more script-instance objects.  <script-manager> will be the new script manager object.  Script managers can be found keyed by URL in the |console.scriptManagers| object.

cmd.hook-script-manager-destroyed.params = <script-manager>
cmd.hook-script-manager-destroyed.help   = Called after <script-manager> has been removed from the |console.scriptManagers| object.  This happens after last contained script-instance is destroyed.

cmd.hook-script-instance-created.params = <script-instance>
cmd.hook-script-instance-created.help   = Called when a new script instance is created.  Script instances delegate commands to one or more script-wrappers.


cmd.hook-script-instance-sealed.params = <script-instance>
cmd.hook-script-instance-sealed.help = Called when <script-instance> is sealed.  Script instances are ``sealed'' when the top level function is created.  This signifies that the script source has been completely compiled.  Any non-function scripts created after this point will appear as a transient in the parent script-manager.

cmd.hook-script-instance-destroyed.params = <script-instance>
cmd.hook-script-instance-destroyed.help   = Called when the final script-wrapper contained by <script-instance> is invalidated.

cmd.hook-source-load-complete.params = <sourceText> <status>
cmd.hook-source-load-complete.help   = Called when the source text represented by the object <sourceText> is loaded (or reloaded.)  <status> indicates the status of the load.  A <status> of 0 indicates success, non-zero values indicate a failure.

cmd.hook-transient-script.params = <script-wrapper>
cmd.hook-transient-script.help   = Called when a script object that appears to be transient (the result of an eval, setTimeout, etc.) is created by the JavaScript engine.

cmd.hook-window-closed.params = <window>
cmd.hook-window-closed.help   = Called when a window object is destroyed.  <window> is a reference to the DOM window object for the window.

cmd.hook-window-loaded.params = <event>
cmd.hook-window-loaded.help   = Called when a source file is loaded into a window object.  <event> is a reference to the DOM event passed to the onLoad handler of the window.

cmd.hook-window-opened.params = <window>
cmd.hook-window-opened.help   = Called when a new window object is opened.  The source for this window will most likely *not* be loaded at this point.  <window> is a reference to the DOM window object for the new window.

cmd.hook-window-resized.params = <window>
cmd.hook-window-resized.help   = Called when the main Venkman window or a floating window is resized.  <window> will be a reference to the window object.

cmd.hook-window-unloaded.params = <event>
cmd.hook-window-unloaded.help   = Called when a source file is unloaded from a window object.  <event> is a reference to the DOM event passed to the onUnload handler of the window.

cmd.hook-venkman-exit.help = Called before the debugger exits.

cmd.hook-venkman-query-exit.help = Called when the debugger would like to exit.  A hook function can set |returnValue| on the event to |false| to cancel the exit.

cmd.hook-venkman-started.help = Called when the debugger first starts up.

## commands ##

cmd.about-mozilla.label = &About Mozilla
cmd.about-mozilla.help  = Display information about your Mozilla installation.

cmd.break.label  = S&et Breakpoint
cmd.break.params = [<url-pattern> <line-number> [<properties> [<parent>]]]
cmd.break.help   = Set a breakpoint in all urls matching <url-pattern> at the line number <line-number>.  <properties> is a JavaScript object representing the properties of the breakpoint.  <parent> is a reference to the Future Breakpoint object to assign as the parent.  If no parameters are specified all active breakpoints will be listed.  See also: |set-fbreak|, |clear|.

cmd.break-props.label  = Breakpoint &Properties...
cmd.break-props.params = <break-wrapper>
cmd.break-props.help   = Display the properties dialog for the breakpoint represented by <break-wrapper>.

cmd.change-container.params = <view-id> <new-type>
cmd.change-container.help   = Changes the type of the container in which <view-id> resides to <new-type>.  <view-id> must be one of: ``scripts'', ``windows'', ``locals'', ``watches'', ``breaks'', ``stack'', ``source'', ``source2'', or ``session''.  <new-type> must be one of: ``horizontal'' for a horizontal layout, ``vertical'' for a vertical layout, or ``tab'' for a tab box layout.

cmd.change-value.label   = Change &Value...
cmd.change-value.params  = <parent-value> <property-name> [<new-value>]
cmd.change-value.help    = Changes the value of the property named <property-name> of the jsdValue <parent-value>.  If the jsdValue <new-value> is specified, this will become the new value of the property, otherwise a dialog box is displayed, allowing the user to enter a new expression for the value.

cmd.chrome-filter.params = [<toggle>]
cmd.chrome-filter.help   = Enables or disabled the filtering of chrome: urls.  With chrome: filtering on, the JavaScript files which make up the browser will not be displayed in the Script View, and the debugger will not step through them while debugging.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.clear.label  = C&lear Breakpoint
cmd.clear.params = <url-pattern> [<line-number>]
cmd.clear.help   = Clears breakpoints in files which match <url-pattern>.  If <line-number> is provided, only breakpoints at that line will be cleared.

cmd.clear-all.label  = Clear &All Breakpoints
cmd.clear-all.help   = Clears every breakpoint currently defined.

cmd.clear-break.label  = &Clear Breakpoint
cmd.clear-break.params = <break-wrapper> [<...>]
cmd.clear-break.help   = Clear the breakpoint wrapped by <break-wrapper>.  If <break-wrapper> is a future breakpoint object, all child breakpoints will be cleared, but the future breakpoint will remain.

cmd.clear-fbreak.label  = Clear &Future Breakpoint
cmd.clear-fbreak.params = <break-wrapper> [<...>]
cmd.clear-fbreak.help   = Clear the future breakpoint wrapped by <break-wrapper>.  If <break-wrapper> is a breakpoint instance object, the instance's parent future breakpoint will be cleared, but the instance will remain.  If the instance has no parent future breakpoint, the wrapper will be ignored.

cmd.clear-profile.label = C&lear Profile Data
cmd.clear-profile.help  = Zeros out any existing profile data.

cmd.clear-session.label = Cle&ar Interactive Session
cmd.clear-session.help  = Clears all text in the Interactive Session view.

cmd.clear-script.label  = &Clear Breakpoint
cmd.clear-script.params = <script-wrapper> [<...>]
cmd.clear-script.help   = Clear all breakpoints in the script wrapped by <script-wrapper>.

cmd.clear-instance.label  = &Clear Breakpoint
cmd.clear-instance.params = <script-instance> [<...>]
cmd.clear-instance.help   = Clear all breakpoints in the script instance referred to by <script-instance>.

cmd.close.label = Close &Window
cmd.close.help  = Close the debugger.

cmd.commands.params = [<pattern>]
cmd.commands.help   = Lists all command names matching <pattern>, or all command names if pattern is not specified.

cmd.copy-frames.label  = &Copy Selected Frames
cmd.copy-frames.params = <jsd-frame> [<...>]
cmd.copy-frames.help   = Copy the selected frames to the clipboard.

cmd.copy-qual-name.label  = Copy &Qualified Name
cmd.copy-qual-name.params = <expression>
cmd.copy-qual-name.help   = Copies the qualified name of a variable to the clipboard.

cmd.cont.label = &Continue
cmd.cont.key   = VK_F5
cmd.cont.tip   = Continue debugging
cmd.cont.help  = Continue execution of the debug target.

cmd.debug-script.label  = Don't &Debug
cmd.debug-script.params = <toggle> <script-wrapper> [<...>]
cmd.debug-script.help   = Enable or disable debugging in the script wrapper <script-wrapper>.  While debugging is disabled, Venkman will *not* stop in the disabled scripts.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.

cmd.debug-instance-on.label  = &Don't Debug Contained Functions
cmd.debug-instance-on.params = <script-instance> [<...>]
cmd.debug-instance-on.help   = Disable debugging in all functions contained by the script instance <script-instance>.

cmd.debug-instance-off.label  = D&ebug Contained Functions
cmd.debug-instance-off.params = <script-instance> [<...>]
cmd.debug-instance-off.help   = Enable debugging in all functions contained by the script instance <script-instance>.

cmd.debug-instance.label  = &Toggle Debugging Contained Functions
cmd.debug-instance.params = <toggle> <script-instance> [<...>]
cmd.debug-instance.help   = Enable or disable debugging in all functions contained by the script instance <script-instance>.  While debugging is disabled, Venkman will *not* stop in the disabled scripts.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.

cmd.debug-transient.label  = Don't Debug Eval/Ti&meouts
cmd.debug-transient.params = <toggle> <url> [<...>]
cmd.debug-transient.help   = Enable or disable debugging of transient scripts (like setTimeout() or eval()) associated with the url <url>.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.

cmd.dumpprofile.label  = Dump Profile Data
cmd.dumpprofile.params = [<file-name>]

cmd.dumptree.params = <tree> [<depth>]

cmd.emode.params = [<mode>]
cmd.emode.help   = Sets what action the debugger should take when an error occurs in the debug target.  |emode ignore| ignores all errors, |emode trace| shows a log of the error in the console, and |emode break| stops excecution when an error is thrown.  |emode| without any parameter will display the current error mode.  Note that |emode| controls what happens when an exception goes uncaught, to control what happens when an exception is *thrown*, use |tmode|.

cmd.eval.params = <expression>
cmd.eval.help   = Evaluates <expression> in the scope of the debug target's current frame.  See also: |frame|, |where|, |props|, and |evald|.

cmd.evald.params = <expression>
cmd.evald.help   = Evaluates <expression> in the debugger's scope.  See also: |eval|.

cmd.em-break.label  = Stop for E&rrors
cmd.em-cycle.label  = Cycle Error Mode
cmd.em-cycle.key    = accel shift  E
cmd.em-ignore.label = Ig&nore Errors
cmd.em-trace.label  = Tr&ace Errors

cmd.fbreak.label  = Set &Future Breakpoint
cmd.fbreak.params = [<url-pattern> <line-number> [<properties>]]
cmd.fbreak.help   = Sets a ``future'' breakpoint.  Any time a script whose file name matches <url-pattern> is loaded, a breakpoint a <line-number> is set.  Setting a breakpoint at line 1 will cause the debugger to break when the script is loaded.  fbreak with no parameters will list all future breakponts.  <properties> is a JavaScript object representing the properties for this breakpoint.  This command is the same as |set-fbreak|, except the parameters are optional.  See also: |break|.

cmd.set-break.label  = S&et Breakpoint
cmd.set-break.params = <url-pattern> <line-number> [<properties> [<parent>]]
cmd.set-break.help   = Set a breakpoint in all urls matching <url-pattern> at the line number <line-number>.  <properties> is a JavaScript object representing the properties of the breakpoint.  <parent> is a reference to the Future Breakpoint object to assign as the parent.  This is the same as the |break| command, except the parameters are required.  See also: |break|, |clear|.

cmd.set-fbreak.label = Set &Future Breakpoint
cmd.set-fbreak.params = <url-pattern> <line-number> [<properties>]
cmd.set-fbreak.help   = Sets a ``future'' breakpoint.  Any time a script whose file name matches <url-pattern> is loaded, a breakpoint a <line-number> is set.  Setting a breakpoint at line 1 will cause the debugger to break when the script is loaded.  <properties> is a JavaScript object representing the properties for this breakpoint.  This command is the same as |fbreak|, except the parameters are not optional.  See also: |break|.

cmd.fclear.label  = Clear F&uture Breakpoint
cmd.fclear.params = <url-pattern> [<line-number>]
cmd.fclear.help   = Clears the future breakpoint(s) set for <url-pattern>.  If <line-number> is specified, only future breakpoints at that line are cleared.

cmd.fclear-all.label = Clear All Fu&ture Breakpoints
cmd.fclear-all.help  = Clears all future breakpoints currently defined.

cmd.find-bp.label  = Find &Breakpoint
cmd.find-bp.params = <breakpoint>
cmd.find-bp.help   = Focus the breakpoint specified by the Breakpoint object <breakpoint>.

cmd.find-creator.label  = Find &Creator
cmd.find-creator.params = <jsd-value>
cmd.find-creator.help   = Focus the creator of the object referenced by the jsdIValue <jsd-value>.

cmd.find-ctor.label  = Find C&onstructor
cmd.find-ctor.params = <jsd-value>
cmd.find-ctor.help   = Focus the constructor of the object referenced by the jsdIValue <jsd-value>.

cmd.find-file.label  = &Open File...
cmd.find-file.key    = accel O
cmd.find-file.params = [<file-name>]
cmd.find-file.help   = Displays the contents of the file located at <file-name> in the script view, where <file-name> is an operating system specific path string.  If <file-name> is not provided, or is the character '?', a file chooser widget will be displayed.

cmd.find-frame.label   = Find &Frame Source
cmd.find-frame.params  = <frame-index>
cmd.find-frame.help    = Focus the stack frame specified by the frame at index <frame-index>.

cmd.find-script.label  = Find F&unction
cmd.find-script.params = <script-wrapper> [<target-pc>]
cmd.find-script.help   = Focus the script wrapped by <script-wrapper>.  If <target-pc> is provided, the view will be scrolled to display the associated line.

cmd.find-sourcetext.params = <source-text> [<range-start> [<range-end> [<details> [<target-line>]]]]
cmd.find-sourcetext.help   = Displays the source text object <sourceText>.  All of the text between <range-start> and <range-end> will be highlighted.  If <details> is provided, it will be an object representing details about where the <source-text> object was derived from.  If <target-line> is provided, the view will be scrolled to that line, otherwise the view will be scrolled to <range-start>.

cmd.find-sourcetext-soft.params = <source-text> [<range-start> [<range-end> [<details> [<target-line>]]]]
cmd.find-sourcetext-soft.help   = Functions the same as |find-sourcetext|, except the view is not scrolled if <target-line> is already visible.

cmd.find-string.label = Fin&d in This File...
cmd.find-string.key   = accel F
cmd.find-string.help  = Brings up a ``Find Dialog'' for the currently selected tab.

cmd.find-scriptinstance.label  = &Find File
cmd.find-scriptinstance.params = <script-instance> [<range-start> [<range-end> [<details> [<target-line>]]]]
cmd.find-scriptinstance.help   = Displays the source text associated with the script instance <script-instance>.  All of the text between <range-start> and <range-end> will be highlighted.  If <details> is provided, it will be an object representing details about where the <script-instance> object was derived from.  If <target-line> is provided, the view will be scrolled to that line, otherwise the view will be scrolled to <range-start>.

cmd.find-url.label  = &Find URL
cmd.find-url.params = <url> [<range-start> [<range-end> [<details> [<target-line>]]]]
cmd.find-url.help   = Displays the contents of the URL <url> in the source view.  All of the text between <range-start> and <range-end> will be highlighted.  If <details> is provided, it will be an object representing details about where the <url> object was derived from.  If <target-line> is provided, the view will be scrolled to that line, otherwise the view will be scrolled to <range-start>.

cmd.find-url-soft.label  = &Soft Focus URL
cmd.find-url-soft.params = <url> [<range-start> [<range-end> [<details> [<target-line>]]]]
cmd.find-url-soft.help   = Functions the same as |find-url|, except the view is not scrolled if <target-line> is already visible.

cmd.finish.label = S&tep Out
cmd.finish.key   = shift VK_F11
cmd.finish.tip   = Step out of the current function
cmd.finish.help  = Execute until the current stack frame returns.

cmd.focus-input.key  = VK_ESCAPE
cmd.focus-input.help = Places focus in the console's text input widget.

cmd.frame.label  = Set &Current Frame
cmd.frame.params = [<frame-index>]
cmd.frame.help   = Sets the current frame to the one numbered <frame-index>, and displays a summary of the frame.  If <frame-index> is not provided, a summary of the current frame will be displayed.  Use the where command to list available frames and frame numbers.

cmd.gc.help = Force the JavaScript garbage collector to run.  This may force unloaded scripts to be removed from the Loaded Scripts view.

cmd.help.label  = &Command Reference
cmd.help.params = [<pattern>]
cmd.help.help   = Displays help on <pattern>, which can be a full command name, or the first few characters of the command name.  If <pattern> matches more than one command, help on all matching commands will be displayed.  If <pattern> is not provided, a command reference will be loaded in a browser window.

cmd.loadd.label  = Load Script in Debugger Scope
cmd.loadd.params = <url>
cmd.loadd.help   = Executes the contents of the url specified by <url> in the context of the debugger.  Useful for loading debugger plugins.  See also: The |initialScripts| pref.

cmd.move-view.params = <view-id> <location-url>
cmd.move-view.help   = Moves the view associated with <view-id> to the location specified by <location-url>.

cmd.mozilla-help.label = &Help Contents
cmd.mozilla-help.help  = Display the table of contents for the Mozilla help system.

cmd.next.label = Step &Over
cmd.next.key   = VK_F12
cmd.next.tip   = Step over function call
cmd.next.help  = Executes the next line of script.  If a function call is encountered it is traced as a single instruction.

cmd.open-dialog.params = <url> [<window-name> [<window-flags>]]
cmd.open-dialog.help   = Opens a dialog window and loads the source from <url>.  This is typically used to open a new XUL window, though it can be used to load a web page without chrome.

cmd.open-url.help  = Prompts the user for a url to load in the source view.
cmd.open-url.label = Open Web &Location...
cmd.open-url.key   = accel shift L

cmd.pprint.params = [<toggle>]
cmd.pprint.help   = Set or display the state of Pretty Print mode.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.pref.params  = [<pref-name> [<pref-value> [<delete-pref>]]]
cmd.pref.help    = Sets the value of the preference named <pref-name> to the value of <pref-value>.  If <pref-value> is not provided, the current value of <pref-name> will be displayed.  If both <pref-name> and <pref-value> are omitted, all preferences will be displayed.  If <delete-pref> is provided and is |true|, |on|, |yes|, or |1|, or if <pref-name> starts with a minus ('-') character, then the preference will revert back to its default value.

cmd.profile.params = [<toggle>]
cmd.profile.help   = Enables or disables the collection of profile data.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.  

cmd.profile-script.label   = Don't &Profile
cmd.profile-script.params = <toggle> <script-wrapper> [<...>]
cmd.profile-script.help   = Enable or disable profiling the script <script-wrapper>.  While profiling is disabled, data will be discarded.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.profile-instance.label = Toggle Profilin&g Contained Functions
cmd.profile-instance.params = <toggle> <script-instance> [<...>]
cmd.profile-instance.help   = Enable or disable profiling in all functions contained by the script instance <script-instance>.  While profiling is disabled, data will be discarded.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.

cmd.profile-instance-on.label  = Don't &Profile Contained Functions
cmd.profile-instance-on.params = <script-instance> [<...>]
cmd.profile-instance-on.help   = Disable profiling in all functions contained by the script instance <script-instance>.

cmd.profile-instance-off.label  = Profile &Contained Functions
cmd.profile-instance-off.params = <script-instance> [<...>]
cmd.profile-instance-off.help   = Enable profiling in all functions contained by the script instance <script-instance>.

cmd.profile-tb.label = Profile
cmd.profile-tb.tip   = Toggle profile mode

cmd.props.params = <expression>
cmd.props.help   = Lists the properties of the value returned by <expression>.  The expression is evaluated in the scope of the debug target's current frame.  See also: |where|, |frame|, |eval|, and |propsd|.

cmd.propsd.params = <expression>
cmd.propsd.help   = Lists the properties of the value returned by <expression>.  The expression is evaluated in the debugger's scope.  See also: |props|.

cmd.exit.label = &Exit
cmd.exit.key   = accel Q

cmd.quit.label = &Quit
cmd.quit.key   = accel Q
cmd.quit.help  = Quit Mozilla.

cmd.reload-source-tab.label  = &Reload Source
cmd.reload-source-tab.params = [<index>]
cmd.reload-source-tab.key    = accel R
cmd.reload-source-tab.help   = Reload the source in the tab located at the index specified by <index>.  If <index> is not provided, the current tab will be reloaded.

cmd.release-notes.label = &Release Notes
cmd.release-notes.help  = Display the Mozilla release notes.

cmd.close-source-tab.label  = &Close Tab
cmd.close-source-tab.key    = accel W
cmd.close-source-tab.params = [<index>]
cmd.close-source-tab.help   = Close the tab located at the index specified by <index>.  If <index> is not provided, the current tab will be closed.

cmd.restore-layout.params = [<name>]
cmd.restore-layout.help   = Restores the view layout named <name>.  If <name> is not provided, the list of available layouts will be displayed.  The special name |factory| can be used to restore a default layout.

cmd.restore-settings.label  = Restore Break/Watch Se&ttings...
cmd.restore-settings.params = [<settings-file>]
cmd.restore-settings.help   = This command is basically an alias to |loadd|, except that <settings-file> is optional.  If <settings-file> is not provided, or is ``?'', a file chooser widget will be displayed.  This command is placed in the context menu of the Breakpoints and Watch views to make it easy to restore saved breakpoints and watches.

cmd.reloadui.key = accel alt R

cmd.run-to.label  = Run To &Line
cmd.run-to.params = <script-wrapper> <pc>
cmd.run-to.help   = Continue execution until program counter specified by <pc>, in the script specified by <script-wrapper> is reached.  The has the effect of setting a ``one time'' breakpoint at the line in question.

cmd.save-default-layout.label = &Save Default Layout Now

cmd.save-layout.params = [<name>]
cmd.save-layout.help   = Saves the current window layout, giving it the name <name>.  The layout can be restored later with the |restore-layout| command.  If <name> is not provided, the list of available layouts will be displayed.  Save to the name ``default'' to set the default layout Venkman restores on startup.  The ``factory'' layout cannot be overwritten.

cmd.save-source-tab.label = &Save Source As...
cmd.save-source-tab.params = [<index> [<target-file>]]
cmd.save-source-tab.key   = accel S
cmd.save-source-tab.help  = Saves the contents of the source file displayed in the tab at the position specified by <index> to a file on the local system.  If <index> is not provided, the current tab is saved.  If <target-file> is not provided, or is the character '?', a file chooser widget will be displayed.  <target-file> is an operating system specific path string.

cmd.save-profile.label = Save P&rofile Data As...
cmd.save-profile.params = [<target-file> [<url> [<...>]]
cmd.save-profile.help = Saves the profile data collected for one or more source files specified by <url> into the file at <target-file>.  If <target-file> is not provided, or is the character '?', a file chooser widget will be displayed.  If <url> is not provided, all profile data is saved.  <target-file> is an operating system specific path string, <url> is a complete url.

cmd.save-breakpoints.label  = &Save Breakpoint Settings...
cmd.save-breakpoints.params = [<settings-file>]
cmd.save-breakpoints.help   = Save the current list of breakpoints to a JavaScript file, so that they can be restored later.  If <settings-file> is not provided, or is the character '?', a file chooser widget will be displayed.  <settings-file> can be a reference to a |LocalFile| object or a string representation of a native path.  See also: |save-settings|, |save-watches|, |restore-settings|.

cmd.save-settings.label  = Sa&ve Break/Watch Settings...
cmd.save-settings.params = [<settings-file>]
cmd.save-settings.help   = Save the current list of breakpoints and watches to a JavaScript file, so that they can be restored later.  If <settings-file> is not provided, or is the character '?', a file chooser widget will be displayed.  <settings-file> can be a reference to a |LocalFile| object or a string representation of a native path.  See also: |save-watches|, |save-breakpoints|, |restore-settings|.

cmd.save-watches.label  = &Save Watch Settings...
cmd.save-watches.params = [<settings-file>]
cmd.save-watches.help   = Save the current list of watches to a JavaScript file, so that they can be restored later.  If <settings-file> is not provided, or is the character '?', a file chooser widget will be displayed.  <settings-file> can be a reference to a |LocalFile| object or a string representation of a native path.  See also: |save-settings|, |save-breakpoints|, |restore-settings|.

cmd.search-scripts.params = [<pattern>]
cmd.search-scripts.help   = Removes any scripts with URLs that do not match <pattern> from the Loaded Scripts view.  If <pattern> is not provided, all scripts will be displayed.

cmd.session-css.params = [<css>]
cmd.session-css.help   = Sets the current CSS file used to style the Interactive Session.  The value of <css> can be the text "default", "dark", or "light" OR a url to the CSS file to use.  The "default" css uses your browser defaults as foreground and background colors, "dark" is dark background in light text, and "light" is light background with dark text.  If <css> is not provided, the current value is printed.

cmd.session-css-default.label = &Browser Defaults
cmd.session-css-dark.label    = &Dark Background/Light Text
cmd.session-css-light.label   = &Light Background/Dark Text

cmd.set-eval-obj.label  = Set as &Evaluation Object
cmd.set-eval-obj.params = <jsd-value>
cmd.set-eval-obj.help   = Sets the current ``evaluation object'' for use with the |eval| command.  The object referenced to by <jsd-value> will become the |this| object, and global variables will be resolved relative to the parent of <jsd-value>.

cmd.scan-source.label  = &Scan For Meta Comments
cmd.scan-source.params = <script-instance>
cmd.scan-source.help   = Scans the entire source file for comments in the form //@JSD_DIRECTIVE.  By default, the directives recognized are //@JSD_LOG, //@JSD_BREAK, and //@JSD_EVAL.  JSD_LOG evaluates whatever script follows it, logging the result to the Interactive Session view.  JSD_BREAK inserts a conditional breakpoint a the next executable line.  JSD_EVAL evaluates whatever script follows it, without logging or breaking.  Users can add additional directives with plug ins.

cmd.scope.help = Lists the properties of the topmost object in the scope chain for the current frame.

cmd.toggle-functions.label  = Include &Functions

cmd.show-functions.params = [<toggle>]
cmd.show-functions.help   = Controls whether or not function properties (sometimes referred to as methods) will be displayed in the Local Varables and Watch views.  After changing this value, you will need to close and open affected nodes in order to see the change.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.toggle-ecmas.label  = &Include ECMA Properties

cmd.show-ecmas.params = [<toggle>]
cmd.show-ecmas.help   = Controls whether or not the ECMA [[Parent]] and [[Prototype]] properties will be displayed in the Local Varables and Watch views.  After changing this value, you will need to close and open affected nodes in order to see the change.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.toggle-constants.label  = Include Cons&tants

cmd.show-constants.params = [<toggle>]
cmd.show-constants.help   = Controls whether or not constant properties will be displayed in the Local Varables and Watch views.  After changing this value, you will need to close and open affected nodes in order to see the change.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.toggle-show-most-recent.label = E&xclude Duplicates

cmd.show-most-recent.params = [<toggle>]
cmd.show-most-recent.help = Controls whether the Loaded Scripts view should show only the most recent script from a given URL, or all of them.  With this off, you may notice duplicate entries in the Loaded Scripts view.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.startup-init.label  = Initialize at &Startup
cmd.startup-init.params = [<toggle>]
cmd.startup-init.help   = Sets the state of the "Initialize at Startup" feature.  With this feature enabled, the debugger will begin tracking scripts when the browser is first started, instead of waiting until the user interface is launched.  This will allow the script list to display files that were loaded before you started the debugger user interface.  This feature incurs a *slight* performance hit.  The value of <toggle> can be |true|, |on|, |yes|, or |1| to turn the flag on; |false|, |off|, |no|, or |0| to turn it off; or |toggle| to invert the current state.  If <toggle> is not provided, the current state will be displayed.

cmd.source-coloring.label  = Colori&ze Source
cmd.source-coloring.params = [<toggle>]
cmd.source-coloring.help   = Enables or disables the source code coloring feature in the Source Code view.  When working with large files, or on a slow machine, source coloring may take too long to be practical.  Turning off source coloring will make files load much faster.  You will need to reload the source code to see the effect of changing this setting.  If <toggle> is not provided, the current state will be displayed.

cmd.stop.label = Sto&p
cmd.stop.key   = VK_F4
cmd.stop.tip   = Stop the current operation
cmd.stop.help  = Stop before the next line of code is executed.

cmd.step.label = Step &Into
cmd.step.key   = VK_F11
cmd.step.tip   = Step into function call
cmd.step.help  = Executes the next line of script and stops.

cmd.testargs.params = <int> <word> [<word2> <word3>]
cmd.testargs.help   = Function for testing argument parsing.  Pass it what it wants, and it'll spit out the event object to stdout.

cmd.testargs1.params = <int> [<...>]
cmd.testargs1.help   = Function for testing argument parsing.  Pass it what it wants, and it'll spit out the event object to stdout.

cmd.this-expr.params = <expression>
cmd.this-expr.help   = Sets the ``evaluation object'' to the result of <expression>.  The evaluation object is used as the |this| object in all evaluations.  The result of <expression> *must* be an object.  See also: |eval|, |props|, |watch-expr|, and |set-eval-obj|.

cmd.tmode.params = [<mode>]
cmd.tmode.help   = Sets what action the debugger should take when an exception is thrown from the debug target.  |tmode ignore| ignores all exceptions, |tmode trace| shows a log of the exception to the console, and |tmode break| stops excecution when an exception is thrown.  |tmode| without any parameter will display the current throw mode.  Note that |tmode| controls what happens when an exception is *thrown*, to control what happens when an exception reaches the top level and becomes an error, use |emode|.  The key combination Control + T can be used to cycle the throw mode.

cmd.tm-break.label  = Stop for &Exceptions
cmd.tm-cycle.label  = Cycle Exception Mode
cmd.tm-cycle.key    = accel T
cmd.tm-ignore.label = I&gnore Exceptions 
cmd.tm-trace.label  = T&race Exceptions

cmd.toggle-scripts-search-box.help   = Toggles the visibility of the search controls in the Loaded Scripts view.

cmd.toggle-float.params = <view-id>
cmd.toggle-float.help   = If the view specified by <view-id> is currently displayed in the main window, or is not visible, it will be placed in a new floating window.  If <view-id> is already in a floating window, it will be placed back in the main window.

cmd.toggle-pprint.label = &Pretty Print
cmd.toggle-pprint.key   = accel P
cmd.toggle-pprint.tip   = Toggle pretty print mode
cmd.toggle-pprint.help  = Toggle Pretty Print mode.

cmd.toggle-save-layout.label = Save Default Layout On &Exit
cmd.toggle-save-layout.help  = If set, the window layout will be saved before Venkman exits.

cmd.toggle-save-settings.label = Save Break/Watch Settings On E&xit
cmd.toggle-save-settings.help  = If set, the breakpoint and watch settings will be saved before Venkman exits, and restored at startup.

cmd.toggle-pref.params = <pref-name>
cmd.toggle-pref.help   = Toggles the boolean preference specified by <pref-name>.

cmd.toggle-view.params = <view-id>
cmd.toggle-view.help   = If the view specified by <view-id> is currently displayed, it will be hidden.  Otherwise the view will be displayed in its last known location.

cmd.toggle-chrome.label  = E&xclude Browser Files
cmd.toggle-profile.label = &Collect Profile Data

cmd.toggle-breaks.label  = &Breakpoints
cmd.toggle-stack.label   = &Call Stack
cmd.toggle-session.label = &Interactive Session
cmd.toggle-locals.label  = &Local Variables
cmd.toggle-scripts.label = Loaded S&cripts
cmd.toggle-windows.label = &Open Windows
cmd.toggle-source.label  = Source Code (old)
cmd.toggle-source2.label = So&urce Code
cmd.toggle-watches.label  = &Watches

cmd.version.label = About &Venkman
cmd.version.help  = Display version information.

cmd.remove-watch.label  = &Remove Watch
cmd.remove-watch.params = <index> [<...>]
cmd.remove-watch.help   = Removes the watch(es) at the 0 based index specified by <index>.

cmd.watch-expr.label = Add &Watch Expression...
cmd.watch-expr.params = [<expression>]
cmd.watch-expr.help   = Evaluates <expression> in the debug target scope and adds the result to the watch window.  If <expression> is not provided, all watches are printed to the console.

cmd.watch-exprd.params = [<expression>]
cmd.watch-exprd.help   = Evaluates <expression> in the debugger scope and adds the result to the watch window.  If <expression> is not provided, all watches are printed to the console.

cmd.watch-property.params = <jsd-value> <property-name>
cmd.watch-property.help   = Adds the property named <property-name> of the object stored in <jsd-value> to the watch window.

cmd.where.label = Dump &Stack to Interactive Session
cmd.where.help = Displays a summarized list of stack frames in the current call chain.