RubyGems - erp_app - Versions diffs - 3.1.16 → 4.0.0 - Mend

erp_app 3.1.16 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1634) hide show

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/manual.html DELETED Viewed

@@ -1,806 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-  <head>
-    <title>CodeMirror: User Manual</title>
-    <link rel="stylesheet" type="text/css" href="css/docs.css"/>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-  </head>
-  <body>
-<h1><span class="logo-braces">{ }</span> <a href="http://codemirror.net/">CodeMirror</a></h1>
-<pre class="grey">
-<img src="css/baboon.png" class="logo" alt="logo"/>/* User manual and
-   reference guide */
-</pre>
-<div class="clear"><div class="leftbig blk">
-    <h2 id="usage">Basic Usage</h2>
-    <p>Inside the editor, the tab key is used to re-indent the current
-    selection (or the current line when nothing is selected), and
-    pressing enter will, apart from inserting a line break,
-    automatically indent the new line. Pressing control-enter will
-    cause the whole buffer to be re-coloured, which can be helpful
-    when some colouring has become out-of-date without the editor
-    noticing it.</p>
-    <p>The editor sports an undo/redo system, accessible with
-    control-z (undo) and control-y (redo). Safari will not allow
-    client scripts to capture control-z presses, but you can use
-    control-backspace instead on that browser.</p>
-    <p>The key-combination control-[ triggers a paren-blink: If the
-    cursor is directly after a '(', ')', '[', ']', '{', or '}', the
-    editor looks for the matching character, and highlights these
-    characters for a moment. There is an option to enable this to
-    happen any time the user types something or moves the cursor.</p>
-    <p>To use CodeMirror in a document, you should add a script tag to
-    load <a href="js/codemirror.js"><code>codemirror.js</code></a>. This
-    adds two objects to your environment, <code>CodeMirror</code> and
-    <code>CodeMirrorConfig</code>. The first is the interface to the
-    editor, the second can be used to configure it. (Note that this is
-    the only name-space pollution you can expect from CodeMirror --
-    all other cruft is kept inside the IFRAMEs that it creates when
-    you open an editor.)</p>
-    <p>To add an editor to a document, you must choose a place, a
-    parser, and a style-sheet for it. For example, to append an
-    XML editor to the body of the document, you do:</p>
-    <pre class="code">var editor = new CodeMirror(document.body, {
-  parserfile: "parsexml.js",
-  stylesheet: "xmlcolors.css"
-});</pre>
-    <p>The first argument to the <code>CodeMirror</code> constructor
-    can be a DOM node, in which case the editor gets appended to that
-    node, or a function, which will be called with the IFRAME node as
-    argument, and which is expected to place that node somewhere in
-    the document.</p>
-    <p>The second (optional) argument is an object that specifies
-    options. A set of default options (see below) is present in the
-    <code>CodeMirrorConfig</code> object, but each instance of the
-    editor can be given a set of specific options to override these
-    defaults. In this case, we specified that the parser should be
-    loaded from the <a
-    href="js/parsexml.js"><code>"parsexml.js"</code></a> file, and
-    that <a href="css/xmlcolors.css"><code>"xmlcolors.css"</code></a>
-    should be used to specify the colours of the code.</p>
-    <p>Another example:</p>
-    <pre class="code">var editor = new CodeMirror(CodeMirror.replace("inputfield"), {
-  parserfile: ["tokenizejavascript.js", "parsejavascript.js"],
-  path: "lib/codemirror/js/",
-  stylesheet: "lib/codemirror/css/jscolors.css",
-  content: document.getElementById("inputfield").value
-});</pre>
-    <p>Here we use the utility function
-    <code>CodeMirror.replace</code> to create a function that will
-    replace a node in the current document (given either directly or
-    by ID) with the editor. We also select the JavaScript parser this
-    time, and give a <code>path</code> option to tell the editor that
-    its files are not located in the same directory as the current
-    HTML page, but in <code>"lib/codemirror/"</code>.</p>
-    <p>There is a function
-    <code>CodeMirror.isProbablySupported()</code> that causes some
-    1998-style browser detection to happen, returning
-    <code>false</code> if CodeMirror is probably not supported on the
-    browser, <code>true</code> if it probably is, and
-    <code>null</code> if it has no idea. As the name suggests, this is
-    not something you can rely on, but it's usually better than
-    nothing.</p>
-    <p>Another utility function, <code>CodeMirror.fromTextArea</code>,
-    will, given a textarea node or the id of such a node, hide the
-    textarea and replace it with a CodeMirror frame. If the textarea
-    was part of a form, an <code>onsubmit</code> handler will be
-    registered with this form, which will load the content of the
-    editor into the textarea, so that it can be submitted as normal.
-    This function optionally takes a configuration object as second
-    argument.</p>
-    <pre class="code">var editor = CodeMirror.fromTextArea("inputfield", {
-  parserfile: ["tokenizejavascript.js", "parsejavascript.js"],
-  path: "lib/codemirror/js/",
-  stylesheet: "lib/codemirror/css/jscolors.css"
-});</pre>
-    <p>Instances created like this will have a
-    <code>toTextArea()</code> method which removes them and restores
-    the text area they were based on, and a <code>save()</code> method
-    which simply updates the textarea with the content of the
-    editor.</p>
-    <p>The reason that the script path has to be configured is that
-    CodeMirror will load in a bunch of extra files when an editor is
-    created (the parser script, among others). To be able to do this,
-    it has to know where to find them. These are all the JavaScript
-    files that are part of CodeMirror itself:</p>
-    <dl>
-      <dt><a href="js/codemirror.js"><code>codemirror.js</code></a></dt>
-      <dd>Main interface, takes care of default configuration and the
-      definition of editor frames. Include this in your HTML
-      document.</dd>
-      <dt><a href="js/editor.js"><code>editor.js</code></a></dt> <dd>The
-      code that takes care of reacting to user input, colouring text,
-      and indenting lines.</dd>
-      <dt><a href="js/util.js"><code>util.js</code></a></dt> <dd>A few
-      generic utility functions.</dd>
-      <dt><a
-      href="js/undo.js"><code>undo.js</code></a></dt>
-      <dd>Implements the undo history for the editor.</dd>
-      <dt><a
-      href="js/stringstream.js"><code>stringstream.js</code></a></dt>
-      <dd>Objects for wrapping the textual input to the parser.</dd>
-      <dt><a href="js/select.js"><code>select.js</code></a></dt> <dd>Some
-      helper utilities for working with selected text and cursor
-      positions.</dd>
-      <dt><a href="js/tokenize.js"><code>tokenize.js</code></a></dt>
-      <dd>Helper framework for writing tokenisers.</dd>
-    </dl>
-    <p>Most of these are rather full of comments, which can be useful
-    when you are trying to figure out how they work, but wastes a lot
-    of bandwidth in a production system. Take a look at the
-    description of the <code>basefiles</code> option below if you want
-    to concatenate and minimise the library (see the <a href="compress.html">compression API</a>).</p>
-    <p>Apart from these, there are files that implement the various
-    parsers. These all start with either <code>parse</code> or
-    <code>tokenize</code>.</p>
-    <h2 id="configuration">Configuration</h2>
-    <p>There are three ways to configure CodeMirror:</p>
-    <ul>
-      <li>If you define a global <code>CodeMirrorConfig</code> object
-      before loading <a
-      href="js/codemirror.js"><code>codemirror.js</code></a>, the
-      configuration options in that object will override the
-      defaults.</li>
-      <li>By assigning to the properties of the
-      <code>CodeMirrorConfig</code> object, configuration defaults can
-      be overridden after loading <a
-      href="js/codemirror.js"><code>codemirror.js</code></a>.</li>
-      <li>The <code>CodeMirror</code> constructor can be given a second
-      argument, an object, which will override some options for just
-      that editor. Options not mentioned in this object will default to
-      the values in the <code>CodeMirrorConfig</code> object.</li>
-    </ul>
-    <p>The options that can be specified are these (most have sensible
-    defaults specified in <a
-    href="js/codemirror.js"><code>codemirror.js</code></a>):</p>
-    <dl>
-      <dt><code>stylesheet</code></dt><dd>The file name of the
-      style-sheet, or style-sheets, that should be used to colour the
-      code in the editor frame. Can be a string or an array of
-      strings. See <a
-      href="css/jscolors.css"><code>jscolors.css</code></a> for an
-      example. The set of active stylesheets can be changed in a
-      running editor with the <code>setStylesheet</code> method, which
-      also takes a string or array of strings as argument.</dd>
-      <dt><code>path</code></dt><dd>The path that is prefixed to
-      script file names when they are loaded into an IFRAME. (Note that
-      this is not applied to the style-sheet file name.)</dd>
-      <dt><code>parserfile</code></dt><dd>A file name string, or an
-      array of strings that name the files containing the parser. See
-      below for the interface that such a parser should
-      implement.</dd>
-      <dt><code>basefiles</code></dt><dd>An array of strings naming
-      the files containing the base CodeMirror functionality. Defaults
-      to <code>["util.js", "stringstream.js", "select.js", "undo.js",
-      "editor.js", "tokenize.js"]</code>, but if you put them all into
-      a single file to reduce latency, or add some functionality, you
-      might have to adjust that.</dd>
-      <dt><code>iframeClass</code></dt><dd>Set this to a string to
-      give the IFRAME node created for the editor a custom CSS class.
-      Defaults to <code>null</code>.</dd>
-      <dt><code>passDelay</code></dt><dd>Gives the amount of
-      milliseconds between colouring passes. Defaults to 200.</dd>
-      <dt><code>passTime</code></dt><dd>Specifies the maximum amount
-      of time that the highlighter will spend in one shot. Setting
-      this too high will cause the editor to 'freeze' the browser for
-      noticeable intervals. Defaults to 50.</dd>
-      <dt><code>continuousScanning</code></dt><dd>Configure continuous
-      scanning of the document. When <code>false</code>, scanning is
-      disabled. When set to a number, say <code>N</code>, a
-      'background' process will scan the document for
-      <code>passTime</code> (see above) milliseconds every
-      <code>N</code> milliseconds, regardless of whether anything
-      changed. This makes sure non-local changes propagate through the
-      document, and will help keep everything consistent. It does add
-      extra processing cost, even for an idle editor. Default value is
-      <code>false</code>.</dd>
-      <dt><code>autoMatchParens</code></dt><dd>When <code>true</code>,
-      will cause parens to be matched every time a key is pressed or
-      the user clicks on the document. Defaults to <code>false</code>.
-      Might be expensive for big documents.</dd>
-      <dt><code>markParen</code>,<code>unmarkParen</code></dt>
-      <dd>Can be used to customise the way brackets are marked (and
-      unmarked) when matched. The simplest way to do this is to simply
-      set <code>markParen</code> to a string, the name of the CSS
-      class that should be added to the bracket elements when they are
-      matched. Alternatively, you can provide an array of two strings,
-      where the first will be used for successful matches, and the
-      second for failing matches. You'll have to include some CSS file
-      (using the <code>stylesheet</code> option) that defines these
-      classes. Alternatively, you can provide both
-      <code>markParen</code> and <code>unmarkParen</code>, and set
-      them to functions that will be called to style the bracket's
-      <code>SPAN</code> elements. Both will get this element as their
-      first argument, and <code>markParen</code> gets a second boolean
-      argument indicating whether a successful match was found. The
-      default behaviour, if these options are not supplied, is to make
-      the brackets bold and green (or red, if not matched).</dd>
-      <dt><code>saveFunction</code></dt><dd>If given a function
-      value, that function will be invoked when the user presses
-      control-s. You should advise your Opera users to use
-      control-shift-s instead, since plain control-s will bring up the
-      'save page' dialog. Defaults to <code>null</code>.</dd>
-      <dt><code>undoDepth</code></dt><dd>Maximum length of the undo
-      history. Default is 50. This setting is changeable with the
-      <code>setUndoDepth(depth)</code> method on CodeMirror
-      instances.</dd>
-      <dt><code>onChange</code></dt><dd>An optional function of zero
-      arguments that gets called whenever the document is changed.
-      Happens at undo-commit time, not instantaniously.</dd>
-      <dt><code>undoDelay</code></dt><dd>When nothing is done in the
-      editor for this amount of milliseconds, pending changes get
-      added to the undo history. Setting this lower will give the undo
-      functionality a finer granularity. Defaults to 800.</dd>
-      <dt><code>width</code>, <code>height</code></dt><dd>The size of
-      the editor frame, given as a style-sheet quantities (for example
-      <code>"600px"</code> or <code>"100%"</code>). When
-      <code>height</code> is set to <code>dynamic</code>, the editor
-      will automatically resize to fit its contents. In this case, the
-      <code>minHeight</code> option (an integer) is used to determine
-      the minimum height in pixels.</dd>
-      <dt><code>disableSpellcheck</code></dt><dd>Should the editor
-      disable spell-checking on browsers that support it (Firefox 2+).
-      Default is <code>true</code>, since for most code spell-checking
-      is useless. Can be changed with the
-      <code>setSpellCheck(on)</code> method.</dd>
-      <dt><code>textWrapping</code></dt><dd>Can be used to disable or
-      enable text-wrapping in the editor frame. Default is
-      <code>true</code>. Changeable with the
-      <code>setTextWrapping(on)</code> method.</dd>
-      <dt><code>lineNumbers</code></dt><dd>Show line numbers to the
-      left of the editor. This requires you to specify a style for the
-      <code>CodeMirror-line-numbers</code> CSS class (in the outer
-      document) to configure the width, font, colors, etcetera for the
-      line-number DIV. You have to make sure that lines in the
-      numbering element have the same height as lines in the editor.
-      This is most easily done by giving them both the same font and
-      an absolute ('pt' or 'px') font size. This option defaults to
-      <code>false</code>. Changeable with the
-      <code>setLineNumbers(on)</code> method.</dd>
-      <dt><code>firstLineNumber</code></dt><dd>When
-      <code>lineNumbers</code> is enabled, this determines the number
-      given to the first line. Default is <code>1</code>.</dd>
-      <dt><code>lineNumberDelay</code>,
-      <code>lineNumberTime</code></dt><dd>When both line numbers are
-      and text wrapping are turned on, updating line numbers can be
-      expensive. These settings can be used to control how fast the
-      updating happens &#x2015; they work in the same way as
-      <code>passDelay</code> and <code>passTime</code>.</dd>
-      <dt><code>onLineNumberClick</code></dt><dd>If given a function
-      value, this function will be called when the user clicks a line
-      number, with the number of the line and the DIV used to display
-      that number as its arguments.</dd>
-      <dt><code>styleNumbers</code></dt><dd>A (somewhat awkward) hook
-      that allows your code to change the style of the line numbers
-      for certain lines (to, for example, highlight them). Whenever
-      the line numbers are updated, the function value given through
-      this option is called with three arguments: <code>(numberDIV,
-      lineNode, lineNum)</code>. It can then update the style of the
-      <code>numberDIV</code> element based on either the BR node at
-      the start of the line (<code>lineNode</code>, which is
-      <code>null</code> for the first line), or the actual line number
-      (<code>lineNum</code>). Note that it might get passed DIVs that
-      were already styled before (the DIVs are reused), so it has to
-      'reset' the style to the default for lines that don't need to be
-      styled.</dd>
-      <dt><code>indentUnit</code></dt><dd>An integer that specifies
-      the amount of spaces one 'level' of indentation should add.
-      Default is <code>2</code>. Changeable in a running editor using
-      the <code>setIndentUnit(spaces)</code> method.</dd>
-      <dt><code>tabMode</code></dt><dd>Determines what the effect of
-      pressing tab is. Possibilities are:
-      <dl>
-        <dt><code>"indent"</code></dt><dd>The default. Causes tab to
-        adjust the indentation of the selection or current line using
-        the parser's rules.</dd>
-        <dt><code>"spaces"</code></dt><dd>Pressing tab simply inserts
-        four spaces.</dd>
-        <dt><code>"default"</code></dt><dd>CodeMirror does not
-        interfere with the tab key, but leaves it to the browser to
-        handle it. Binds shift-space to regular indentation
-        behaviour.</dd>
-        <dt><code>"shift"</code></dt><dd>Pressing tab indents the
-        current line (or selection) one <code>indentUnit</code>
-        deeper, pressing shift-tab, un-indents it.</dd>
-      </dl>
-      This option can be changed at run-time using the
-      <code>setTabMode(mode)</code> method.</dd>
-      <dt><code>enterMode</code></dt><dd>Determines how a new line
-      created by pressing enter is indented. Supported modes are:
-      <dl>
-        <dt><code>"indent"</code></dt><dd>The default. Causes the new
-        line to be intented by the rules of the parser.</dd>
-        <dt><code>"keep"</code></dt><dd>Keeps the indentation of the
-        previous line.</dd>
-        <dt><code>"flat"</code></dt><dd>Never indents new lines.</dd>
-      </dl>
-      The <code>setEnterMode</code> method can be used to change this
-      option in a running editor.</dd>
-      <dt><code>electricChars</code></dt><dd>A boolean that can be
-      used to turn "electric chars" (characters that cause the current
-      line to be reindented when typed, such as <code>{</code> and
-      <code>}</code> in C-like languages) on and off. Default is
-      on.</dd>
-      <dt><code>reindentOnLoad</code></dt><dd>When <code>true</code>,
-      this causes the content of the editor to be reindented
-      immediately when the editor loads. Defaults to
-      <code>false</code>.</dd>
-      <dt><code>readOnly</code></dt><dd>When set to <code>true</code>,
-      the document is not editable.</dd>
-      <dt><code>domain</code></dt><dd>Can be set to the value
-      <code>document.domain</code> should have inside of the iframe.
-      Used to prevent access issues in IE, where this value isn't
-      automatically inherited by iframes.</dd>
-      <dt><code>noScriptCaching</code></dt><dd>The scripts loaded
-      inside the editor frame are not affected by, for example,
-      ctrl-F5 on Firefox, and will often be cached even though you
-      don't want them to. During development, you can set this option
-      to <code>true</code> to cause CodeMirror to add a changing dummy
-      parameter to the script URLs, which will force browsers to
-      reload them every time.</dd>
-      <dt><code>onLoad</code></dt><dd>If set to a function, this
-      will be called (with the editor object as its argument) after
-      the editor has finished initialising.</dd>
-      <dt><code>onCursorActivity</code></dt><dd>A function that is
-      called every time the cursor moves, with the top-level node that
-      the cursor is inside or next to as an argument. Can be used to
-      have some controls react to the context of the cursor.</dd>
-      <dt><code>activeTokens</code></dt><dd>Can be set to a function
-      that will be called with <code>(spanNode, tokenObject,
-      editor)</code> arguments whenever a new token node is being
-      added to the document. Can be used to do things like add event
-      handlers to nodes. Should <em>not</em> change the DOM structure
-      of the node (so no turning the span into a link), since this
-      will greatly confuse the editor.</dd>
-      <dt id="parserConfig"><code>parserConfig</code></dt><dd>An
-      object value that is passed along to the parser to configure it.
-      What this object should look like depends on the parser
-      used.</dd>
-      <dt><code>content</code></dt><dd>The starting content of the
-      editor. You'll probably not want to provide a global default for
-      this, but add it to the <code>options</code> object passed to
-      individual editors as they are created.</dd>
-    </dl>
-    <h2 id="parsers">Parsers</h2>
-    <p>(If you want to use a CodeMirror parser to highlight a piece of
-    text, without creating an editor, see <a
-    href="highlight.html">this example</a>, and the <code><a
-    href="js/highlight.js">highlight.js</a></code> script.)</p>
-    <p>The following parsers come with the distribution of CodeMirror:</p>
-    <dl>
-      <dt><code><a href="js/parsexml.js">parsexml.js</a></code> (<a
-      href="htmltest.html">demo</a>)</dt><dd>A HTML/XML parser. Takes
-      a <code>useHTMLKludges</code> configuration option (see the
-      <code><a href="#parserConfig">parserConfig</a></code> option
-      above), which specifies whether the content of the editor is
-      HTML or XML, and things like self-closing tags (<code>br</code>,
-      <code>img</code>) exist. This defaults to <code>true</code>.
-      Example colours for the styles that this parser uses are defined
-      in <code><a
-      href="css/xmlcolors.css">css/xmlcolors.css</a></code>.</dd>
-      <dt><code><a
-      href="js/tokenizejavascript.js">tokenizejavascript.js</a></code>,
-      <code><a
-      href="js/parsejavascript.js">parseejavascript.js</a></code> (<a
-      href="jstest.html">demo</a>)</dt><dd>The JavaScript parser.
-      Example colours in <code><a
-      href="css/jscolors.css">css/jscolors.css</a></code>. Takes one
-      configuration option, <code>json</code>, that can be set when
-      the editor content is JSON data. It causes every opening brace
-      to be treated as the start of an object, rather than a
-      block.</dd>
-      <dt><code><a href="js/parsecss.js">parsecss.js</a></code> (<a
-      href="csstest.html">demo</a>)</dt><dd>A CSS parser. Styles in
-      <code><a
-      href="css/csscolors.css">css/csscolors.css</a></code></dd>
-      <dt><code><a
-      href="js/parsehtmlmixed.js">parsehtmlmixed.js</a></code> (<a
-      href="mixedtest.html">demo</a>)</dt><dd>A mixed-mode HTML
-      parser. By default, requires the XML, JavaScript, and CSS
-      parsers to also be loaded, so your <code>parserfile</code>
-      option looks something like <code>["parsexml.js", "parsecss.js",
-      "tokenizejavascript.js", "parsejavascript.js",
-      "parsehtmlmixed.js"]</code>. This parser accepts a configuration
-      object with a <code>triggers</code> property to configure which
-      parser should be invoked for which tag. The default looks like
-      this (property names are tags, values are parser names):
-      <code>{script: "JSParser", style: "CSSParser"}</code></dd>
-      <dt><code><a href="js/parsesparql.js">parsesparql.js</a></code>
-      (<a href="sparqltest.html">demo</a>)</dt><dd>Parses the <a
-      href="http://en.wikipedia.org/wiki/SPARQL">SPARQL</a> query
-      language. Example styles in <code><a
-      href="css/sparqlcolors.css">css/sparqlcolors.css</a></code></dd>
-      <dt><code><a
-      href="js/parsedummy.js">parsedummy.js</a></code></dt><dd>A
-      'dummy' parser to make it possible to edit plain text, or
-      documents for which no suitable parser exists.</dd>
-      <dt><code><a
-      href="contrib/php/js/parsephp.js">contrib/php/js/parsephp.js</a></code>
-      (<a href="contrib/php/index.html">demo</a>)</dt><dd>PHP parser.
-      There is also <code><a
-      href="contrib/php/js/parsephphtmlmixed.js">contrib/php/js/parsephphtmlmixed.js</a></code>,
-      which wraps this parser to allow mixed-mode HTML + PHP parsing.
-      This one takes a configuration parameter <code>opening</code>,
-      which should contain an array of XML processing instruction
-      openings (<code>&lt;?php</code>, <code>&lt;?</code> etc) which
-      can be used to open a PHP block. Default is
-      <code>["&lt;?php"]</code>.</dd>
-      <dt><code><a
-      href="contrib/python/js/parsepython.js">contrib/python/js/parsepython.js</a></code>
-      (<a href="contrib/python/index.html">demo</a>)</dt><dd>Python
-      parser.</dd>
-      <dt><code><a href="contrib/lua/js/parselua.js">contrib/lua/js/parselua.js</a></code>
-      (<a href="contrib/lua/index.html">demo</a>)</dt><dd>Lua
-      parser.</dd>
-    </dl>
-    <h2 id="programming">Programming Interface</h2>
-    <p>To be as flexible as possible, CodeMirror implements a very
-    plain editable field, without any accompanying buttons, bells, and
-    whistles. <code>CodeMirror</code> objects do, however, provide a
-    number of methods and properties that make it possible to add
-    extra functionality around the editor. <a
-    href="js/mirrorframe.js"><code>mirrorframe.js</code></a> provides
-    a basic example of their usage.</p>
-    <h3 id="properties">Properties</h3>
-    <dl>
-      <dt><code>frame</code></dt><dd>The editable frame.</dd>
-      <dt><code>win</code></dt><dd>The window of the editable frame.
-      Mostly useful for attaching event handlers.</dd>
-      <dt><code>wrapping</code></dt><dd>The <code>DIV</code> element
-      wrapped around the frame. This always has a CSS class of
-      <code>CodeMirror-wrapping</code>.</dd>
-    </dl>
-    <h3 id="methods">Methods</h3>
-    <dl>
-      <dt><code>getCode()</code> &#8594;
-      <code>string</code></dt><dd>Returns the current content of the
-      editor, as a string.</dd>
-      <dt><code>setCode(string)</code></dt><dd>Replaces the current
-      content of the editor with the given value.</dd>
-      <dt><code>focus()</code></dt><dd>Gives focus to the editor
-      frame.</dd>
-      <dt><code>selection()</code> &#8594;
-      <code>string</code></dt><dd>Returns the text that is currently
-      selected in the editor.</dd>
-      <dt><code>replaceSelection(string)</code></dt><dd>Replaces the
-      currently selected text with the given string. Will also cause
-      the editor frame to gain focus.</dd>
-      <dt><code>reindent()</code></dt><dd>Automatically re-indent the
-      whole document.</dd>
-      <dt><code>reindentSelection()</code></dt><dd>Automatically
-      re-indent the selected lines.</dd>
-      <dt><code>getSearchCursor(pattern, startPos, caseFold)</code>
-      &#8594; <code>cursor</code></dt><dd>The first argument provides
-      the pattern that should be searched for. It can be a string or a
-      regular expression (with the caveat that regexps won't match
-      across line boundaries, whereas strings will). The second
-      determines where to start searching. It can
-      be <code>false</code> (or left off) for the start of the
-      document, <code>true</code> for the current cursor position, or
-      a <code>{line, character}</code> object (as returned
-      by <code>cursorPosition</code>, or created yourself using a line
-      handle and a number) to set a random position. The third
-      argument, a boolean, determines whether the search will be
-      case-sensitive. If it is not provided, the search will only be
-      case-sensitive if the search string contains uppercase
-      characters. Returns an object that provides an interface for
-      searching. Call its <code>findNext()</code> and
-      <code>findPrevious()</code> methods to search for an occurrence.
-      This returns <code>true</code> if something is found, or
-      <code>false</code> if the end or start of the document was
-      reached. When an occurrence has been found, you can call
-      <code>select()</code> to select it, or
-      <code>replace(string)</code> to replace it with a given string
-      (you can use \1 placeholders in this string if you matched a
-      regular expression). To find out where the match was found, call
-      the <code>position()</code> method, which returns a <code>{line,
-      character}</code> object. Note that letting the user change the
-      document, or programmatically changing it in any way except for
-      calling <code>replace</code> on the cursor itself, might cause a
-      cursor object to skip back to the beginning of the
-      document.</dd>
-      <dt><code>undo()</code></dt><dd>Undo one changeset, if available.</dd>
-      <dt><code>redo()</code></dt><dd>Redo one changeset, if available.</dd>
-      <dt><code>historySize() &#8594; object</code></dt><dd>Get a
-      <code>{undo, redo}</code> object holding the sizes of the undo
-      and redo histories.</dd>
-      <dt><code>clearHistory()</code></dt><dd>Drop all history
-      information.</dd>
-      <dt><code>grabKeys(callback, filter)</code></dt><dd>Route
-      keyboard input in the editor to a callback function. This
-      function is given a slightly normalised (see
-      <code>normalizeEvent</code> in <a
-      href="js/util.js"><code>util.js</code></a>) <code>keydown</code>
-      event object. If a second argument is given, this will be used
-      to determine which events to apply the callback to. It should
-      take a key code (as in <code>event.keyCode</code>), and return a
-      boolean, where <code>true</code> means the event should be
-      routed to the callback, and <code>false</code> leaves the key to
-      perform its normal behaviour.</dd>
-      <dt><code>ungrabKeys()</code></dt><dd>Revert the effect of
-      <code>grabKeys</code>.</dd>
-      <dt><code>setParser(name, parserConfig)</code></dt><dd>Change
-      the active parser. To use this you'll have to load more than one
-      parser (put the one you want to use as default at the end of the
-      list). Then call this function with a string containing the name
-      of the parser you want to switch to (see the parser script file
-      to find the name, it'll be something like
-      <code>CSSParser</code>). The second argument is optional, and
-      can be used to pass a new parser configuration object.</dd>
-      <dt><code>cursorCoords(start)</code></dt><dd>Get the coordinates
-      of the cursor in the editor, relative to the top-left corner of
-      the outer document. Normally returns an object with
-      <code>x</code>, <code>y</code>, and <code>yBot</code> (the
-      bottom of the cursor) properties. May return <code>null</code>
-      if the cursor position could not be determined (for example, if
-      the editor is not focused).</dd>
-    </dl>
-    <h3 id="lines">Line Manipulation</h3>
-    <p>For detailed interaction with the content of the editor,
-    CodeMirror exposes a line-oriented interface, which allows you to
-    inspect and manipulate the document line by line. Line handles
-    should be considered opaque (they are in fact the <code>BR</code>
-    nodes at the start of the line), except that the value
-    <code>false</code> (but <em>not</em> <code>null</code>) always
-    denotes an invalid value. Since changing the document might cause
-    some line handles to become invalid, every function that takes
-    them as argument can throw
-    <code>CodeMirror.InvalidLineHandle</code>. These are the relevant
-    methods:</p>
-    <dl>
-      <dt><code>cursorPosition(start)</code> &#8594;
-      <code>object</code></dt><dd>Retrieve a <code>{line,
-      character}</code> object representing the cursor position.
-      <code>start</code> defaults to <code>true</code> and determines
-      if the startpoint or the endpoint of the selection is used.</dd>
-      <dt><code>cursorLine()</code> &#8594;
-      <code>handle</code></dt><dd>Returns the line on which the cursor
-      is currently sitting.</dd>
-      <dt><code>firstLine()</code> &#8594;
-      <code>handle</code></dt><dd>Get the first line of the
-      document.</dd>
-      <dt><code>lastLine()</code> &#8594;
-      <code>handle</code></dt><dd>The last line.</dd>
-      <dt><code>nextLine(handle)</code> &#8594;
-      <code>handle</code></dt><dd>Get the line after the given one, or
-      <code>false</code> if that was the last line.</dd>
-      <dt><code>prevLine(handle)</code> &#8594;
-      <code>handle</code></dt><dd>Find the line before the given one,
-      return <code>false</code> if that was the first line.</dd>
-      <dt><code>nthLine(number)</code> &#8594;
-      <code>handle</code></dt><dd>Find the Nth line of the document.
-      Note that the first line counts as one, not zero. Returns
-      <code>false</code> if there is no such line.</dd>
-      <dt><code>lineContent(handle)</code> &#8594;
-      <code>string</code></dt><dd>Retrieve the content of the
-      line.</dd>
-      <dt><code>setLineContent(handle, string)</code></dt><dd>Replace
-      the content of the line with the given string.</dd>
-      <dt><code>removeLine(handle)</code></dt><dd>Remove the given
-      line from the editor. The handle will stay valid after this
-      operation, and now refers to the next line.</dd>
-      <dt><code>lineNumber(handle)</code> &#8594;
-      <code>number</code></dt><dd>Ask which line of the document
-      (1-based) the given line is.</dd>
-      <dt><code>jumpToLine(handle)</code></dt><dd>Moves the cursor to
-      the start of the given line.</dd>
-      <dt><code>selectLines(startHandle, startOffset,
-      endHandle, endOffset)</code></dt><dd>Move the selection to a
-      specific point. <code>endHandle</code> and
-      <code>endOffset</code> can be omitted to just place the cursor
-      somewhere without selecting any text.</dd>
-      <dt><code>insertIntoLine(handle, position,
-      text)</code></dt><dd>Insert a piece of text into a line.
-      <code>position</code> can be an integer, specifying the position
-      in the line where the text should be inserted, or the string
-      <code>"end"</code>, for the end of the line.</dd>
-    </dl>
-    <h2 id="writeparser">Writing a Parser</h2>
-    <p>A parser is implemented by one or more files (see
-    <code>parserfile</code> above) which, when loaded, add a
-    <code>Parser</code> property to the <code>Editor</code> object
-    defined by <a href="js/editor.js"><code>editor.js</code></a>. This
-    object must support the following interface:</p>
-    <dl>
-      <dt><code>make(stream)</code></dt><dd>A function that, given a
-      string stream (see <a
-      href="js/stringstream.js"><code>stringstream.js</code></a>),
-      creates a parser. The behaviour of this parser is described
-      below.</dd>
-      <dt><code>electricChars</code></dt><dd>An optional string
-      containing the characters that, when typed, should cause the
-      indentation of the current line to be recomputed (for example
-      <code>"{}"</code> for c-like languages).</dd>
-      <dt><code>configure(object)</code></dt><dd>An optional function
-      that can be used to configure the parser. If it exists, and an
-      editor is given a <code>parserConfig</code> option, it will be
-      called with the value of that option.</dd>
-      <dt><code>firstIndentation(chars, current,
-      direction)</code></dt><dd>An optional function that is used to
-      determine the proper indentation of the first line of a
-      document. When not provided, <code>0</code> is used.</dd>
-    </dl>
-    <p>When the <code>make</code> method is called with a string
-    stream, it should return a MochiKit-style iterator: an object with
-    a <code>next</code> method, which will raise
-    <code>StopIteration</code> when it is at its end (see <a
-    href="http://bob.pythonmac.org/archives/2005/07/06/iteration-in-javascript/">this</a>
-    for details). This iterator, when called, will consume input from
-    the string stream, and produce a token object.</p>
-    <p>Token objects represent a single significant piece of the text
-    that is being edited. A token object must have a
-    <code>value</code> property holding the text it stands for, and a
-    <code>style</code> property with the CSS class that should be used
-    to colour this element. This can be anything, except that any
-    whitespace at the start of a line should <em>always</em> have
-    class <code>"whitespace"</code>: The editor must be able to
-    recognize these when it indents lines. Furthermore, each newline
-    character <em>must</em> have its own separate token, which has an
-    <code>indentation</code> property holding a function that can be
-    used to determine the proper indentation level for the next line.
-    This function optionally takes the text in the first token of the
-    next line, the current indentation of the line, and the
-    'direction' of the indentation as arguments, which it can use to
-    adjust the indentation level. The direction argument is only
-    useful for modes in which lines do not have a fixed indentation,
-    and can be modified by multiple tab presses. It is
-    <code>null</code> for 'default' indentations (like what happens
-    when the user presses enter), <code>true</code> for regular tab
-    presses, and <code>false</code> for control-tab or shift-tab.</p>
-    <p>So far this should be pretty easy. The hard part is that this
-    iterator must also have a <code>copy</code> method. This method,
-    called without arguments, returns a function representing the
-    current state of the parser. When this state function is later
-    called with a string stream as its argument, it returns a parser
-    object that resumes parsing using the old state and the new input
-    stream. It may assume that only one parser is active at a time,
-    and can clobber the state of the old parser if it wants.</p>
-    <p>For examples, see <a
-    href="js/parsejavascript.js"><code>parsejavascript.js</code></a>,
-    <a href="js/parsexml.js"><code>parsexml.js</code></a>, and <a
-    href="js/parsecss.js"><code>parsecss.js</code></a>.</p>
-</div><div class="rightsmall blk">
-  <h2>Contents</h2>
-  <ul>
-    <li><a href="#usage">Basic Usage</a></li>
-    <li><a href="#configuration">Configuration</a></li>
-    <li><a href="#parsers">Parsers</a></li>
-    <li><a href="#programming">Programming Interface</a>
-    <ul>
-      <li><a href="#properties">Properties</a></li>
-      <li><a href="#methods">Methods</a></li>
-      <li><a href="#lines">Line Manipulation</a></li>
-    </ul>
-    </li>
-    <li><a href="#writeparser">Writing a Parser</a></li>
-  </ul>
-  <h2>Site</h2>
-  <ul>
-    <li><a href="index.html">Front Page</a></li>
-    <li><a href="faq.html">FAQ</a></li>
-    <li><a href="http://groups.google.com/group/codemirror">Google Group</a></li>
-    <li><a href="compress.html">Compression Helper</a></li>
-    <li><a href="story.html">War Story</a></li>
-  </ul>
-</div></div>
-<div style="height: 2em">&nbsp;</div>
-<script type="text/javascript" src="css/font.js"></script>
-  </body>
-</html>