RubyGems - erp_app - Versions diffs - 3.0.0 → 3.0.1 - Mend

erp_app 3.0.0 → 3.0.1

Files changed (909) hide show

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

@@ -0,0 +1,806 @@
+<!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>