suzanne.soy/scribble-mathjax
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'v2.1-latest' into develop

Browse Source
This commit is contained in:
Davide P. Cervone 2012-09-24 21:37:23 -04:00
commit 45a05f8bae
215 changed files with 47 additions and 45248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/.gitignore vendored
View File

@ -1,10 +0,0 @@
.doctrees
html-mathjax-site
dirhtml
singlehtml
epub
latex
text
man
html/objects.inv
html/.buildinfo

137
docs/Makefile
View File

@ -1,137 +0,0 @@
# Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = .
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/.doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
# @echo " pickle to make pickle files"
# @echo " json to make JSON files"
# @echo " htmlhelp to make HTML files and a HTML help project"
# @echo " qthelp to make HTML files and a qthelp project"
# @echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
@echo "or"
@echo " html-mathjax-site to make the documentation for www.mathjax.org"
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
html-mathjax-site:
$(SPHINXBUILD) -b html -A for_site=True $(ALLSPHINXOPTS) $(BUILDDIR)/html-mathjax-site
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html-mathjax-site."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/UCBerkeleyAstronomy10Spring2011.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/UCBerkeleyAstronomy10Spring2011.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/UCBerkeleyAstronomy10Spring2011"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/UCBerkeleyAstronomy10Spring2011"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
make -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."

11
docs/README.txt Normal file
View File

@ -0,0 +1,11 @@
The source files for the documentation are now kept in a separate
GitHub repository at
https://github.com/mathjax/mathjax-docs
The HTML versions are now available at
http://mathjax.readthedocs.org/en/latest/
where it is possible for you to submit corrections and modifications
directly to the documentation on line.

173
docs/html/CSS-styles.html
View File

@ -1,173 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>CSS Style Objects &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="next" title="Glossary" href="glossary.html" />
<link rel="prev" title="Describing HTML snippets" href="HTML-snippets.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="glossary.html" title="Glossary"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="HTML-snippets.html" title="Describing HTML snippets"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="css-style-objects">
<span id="id1"></span><h1>CSS Style Objects<a class="headerlink" href="#css-style-objects" title="Permalink to this headline"></a></h1>
<p>Many MathJax components allow you to specify CSS styles that control
the look of the elements they create. These are described using <cite>CSS
style objects</cite>, which are JavaScript objects that represent standard
CSS declarations. The main CSS style object is a collection of
<cite>name:value</cite> pairs where the <cite>name</cite> is the CSS selector that is being
defined, and the <cite>value</cite> is an object that gives the style for that
selector. Most often, the selector will need to be enclosed in
quotation marks, as it will contain special characters, so you would
need to use <tt class="docutils literal"><span class="pre">&quot;#myID&quot;</span></tt> rather than just <tt class="docutils literal"><span class="pre">#myID</span></tt> and <tt class="docutils literal"><span class="pre">&quot;ul</span> <span class="pre">li&quot;</span></tt>
rather than just <tt class="docutils literal"><span class="pre">ul</span> <span class="pre">li</span></tt>.</p>
<p>The value used to define the CSS style can either be a string
containing the CSS definition, or a javascript object that is itself a
collection of <cite>name:value</cite> pairs, where the <cite>name</cite> is the attribute
being defined and <cite>value</cite> is the value that attribute should be given.
Note that, since this is a JavaScript object, the pairs are separated
by commas (not semi-colons) and the values are enclosed in quotation
marks. If the name contains dashes, it should be enclosed in
quotation marks as well.</p>
<p>For example, <tt class="docutils literal"><span class="pre">jax/output/HTML-CSS/config.js</span></tt> includes the following
declaration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">styles</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;.MathJax_Display&quot;</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;text-align&quot;</span><span class="o">:</span> <span class="s2">&quot;center&quot;</span><span class="p">,</span>
<span class="nx">margin</span><span class="o">:</span> <span class="s2">&quot;1em 0em&quot;</span>
<span class="p">},</span>
<span class="s2">&quot;.MathJax .merror&quot;</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;background-color&quot;</span><span class="o">:</span> <span class="s2">&quot;#FFFF88&quot;</span><span class="p">,</span>
<span class="nx">color</span><span class="o">:</span> <span class="s2">&quot;#CC0000&quot;</span><span class="p">,</span>
<span class="nx">border</span><span class="o">:</span> <span class="s2">&quot;1px solid #CC0000&quot;</span><span class="p">,</span>
<span class="nx">padding</span><span class="o">:</span> <span class="s2">&quot;1px 3px&quot;</span><span class="p">,</span>
<span class="s2">&quot;font-style&quot;</span><span class="o">:</span> <span class="s2">&quot;normal&quot;</span><span class="p">,</span>
<span class="s2">&quot;font-size&quot;</span><span class="o">:</span> <span class="s2">&quot;90%&quot;</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</div>
<p>This defines two CSS styles, one for the selector
<tt class="docutils literal"><span class="pre">.MathJax_Display</span></tt>, which specifies its text alignment and margin
settings, and a second for <tt class="docutils literal"><span class="pre">.MathJax</span> <span class="pre">.merror</span></tt>, which specifies a
background color, foreground color, border, and so on.</p>
<p>You can add as many such definitions to a <tt class="docutils literal"><span class="pre">styles</span></tt> object as you
wish. Note, however, that since this is a JavaScript object, the
selectors must be unique (e.g., you can&#8217;t use two definitions for
<tt class="docutils literal"><span class="pre">&quot;img&quot;</span></tt>, for example, as only the last one would be saved). If you
need to use more than one entry for a single selector, you can add
comments like <tt class="docutils literal"><span class="pre">/*</span> <span class="pre">1</span> <span class="pre">*/</span></tt> and <tt class="docutils literal"><span class="pre">/*</span> <span class="pre">2</span> <span class="pre">*/</span></tt> to the selector to make them
unique.</p>
<p>It is possible to include selectors like <tt class="docutils literal"><span class="pre">&quot;&#64;media</span> <span class="pre">print&quot;</span></tt>, in which
case the value is a CSS style object. For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">styles</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;@media print&quot;</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;.MathJax .merror&quot;</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;background-color&quot;</span><span class="o">:</span> <span class="s2">&quot;white&quot;</span><span class="p">,</span>
<span class="nx">border</span><span class="o">:</span> <span class="mi">0</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</div>
<p>The various extensions and output processors include more examples of
CSS style objects, so see the code for those files for additional
samples. In particular, the <tt class="docutils literal"><span class="pre">extensions/MathMenu.js</span></tt>,
<tt class="docutils literal"><span class="pre">extensions/MathZoom.js</span></tt>, <tt class="docutils literal"><span class="pre">extensions/FontWarnsing.js</span></tt>, and
<tt class="docutils literal"><span class="pre">jax/output/HTML-CSS/jax.js</span></tt> files include such definitions.</p>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h4>Previous topic</h4>
<p class="topless"><a href="HTML-snippets.html"
title="previous chapter">Describing HTML snippets</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="glossary.html"
title="next chapter">Glossary</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="glossary.html" title="Glossary"
>next</a> |</li>
<li class="right" >
<a href="HTML-snippets.html" title="Describing HTML snippets"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

168
docs/html/HTML-snippets.html
View File

@ -1,168 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Describing HTML snippets &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="next" title="CSS Style Objects" href="CSS-styles.html" />
<link rel="prev" title="The MathJax Object-Oriented Programming Model" href="api/object.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="CSS-styles.html" title="CSS Style Objects"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="api/object.html" title="The MathJax Object-Oriented Programming Model"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="describing-html-snippets">
<span id="html-snippets"></span><h1>Describing HTML snippets<a class="headerlink" href="#describing-html-snippets" title="Permalink to this headline"></a></h1>
<p>A number of MathJax configuration options allow you to specify an HTML
snippet using a JavaScript object. This lets you include HTML in your
configuration files even though they are not HTML files themselves.
The format is fairly simple, but flexible enough to let you represent
complicated HTML trees.</p>
<p>An HTML snippet is an array consisting of a series of elements that format
the HTML tree. Those elements are one of two things: either a string,
which represents text to be included in the snippet, or an array,
which represents an HTML tag to be included. In the latter case, the
array consists of three items: a string that is the tag name (e.g.,
&#8220;img&#8221;), an optional object that gives attributes for the tag (as
described below), and an optional HTML snippet array that gives the
contents of the tag.</p>
<p>When attributes are provided, they are given as <cite>name:value</cite> pairs,
with the <cite>name</cite> giving the attribute name, and <cite>value</cite> giving its
value. For example</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[[</span><span class="s2">&quot;img&quot;</span><span class="p">,{</span><span class="nx">src</span><span class="o">:</span><span class="s2">&quot;/images/mypic.jpg&quot;</span><span class="p">}]]</span>
</pre></div>
</div>
<p>represents an HTML snippet that includes one element: an <tt class="docutils literal"><span class="pre">&lt;img&gt;</span></tt> tag
with <tt class="docutils literal"><span class="pre">src</span></tt> set to <tt class="docutils literal"><span class="pre">/images/mypic.jpg</span></tt>. That is, this is
equivalent to</p>
<div class="highlight-html"><div class="highlight"><pre><span class="nt">&lt;img</span> <span class="na">src=</span><span class="s">&quot;/images/mypic.jpg&quot;</span><span class="nt">&gt;</span>
</pre></div>
</div>
<p>Note that the snippet has two sets of square brackets. The outermost
one is for the array that holds the snippet, and the innermost set is
because the first (and only) element in the snippet is a tag, not
text. Note that the code <tt class="docutils literal"><span class="pre">[&quot;img&quot;,{src:&quot;/images/mypic.jpg&quot;}]</span></tt>
is invalid as an HTML snippet. It would represent a snippet that
starts with &#8220;img&#8221; as text in the snippet (not a tag), but the second
item is neither a string nor an array, and so is illegal. This is a
common mistake that should be avoided.</p>
<p>A more complex example is the following:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[</span>
<span class="s2">&quot;Please read the &quot;</span><span class="p">,</span>
<span class="p">[</span><span class="s2">&quot;a&quot;</span><span class="p">,{</span><span class="nx">href</span><span class="o">:</span><span class="s2">&quot;instructions.html&quot;</span><span class="p">},[</span><span class="s2">&quot;instructions&quot;</span><span class="p">]],</span>
<span class="s2">&quot; carefully before proceeding&quot;</span>
<span class="p">]</span>
</pre></div>
</div>
<p>which is equivalent to</p>
<div class="highlight-html"><div class="highlight"><pre>please read the <span class="nt">&lt;a</span> <span class="na">href=</span><span class="s">&quot;instructions.html&quot;</span><span class="nt">&gt;</span>instructions<span class="nt">&lt;/a&gt;</span> carefully
before proceeding.
</pre></div>
</div>
<p>A final example shows how to set style attributes on an object:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[[</span><span class="s2">&quot;span&quot;</span><span class="p">,</span>
<span class="p">{</span>
<span class="nx">id</span><span class="o">:</span><span class="s2">&quot;mySpan&quot;</span><span class="p">,</span>
<span class="nx">style</span><span class="o">:</span> <span class="p">{</span><span class="nx">color</span><span class="o">:</span><span class="s2">&quot;red&quot;</span><span class="p">,</span> <span class="s2">&quot;font-weight&quot;</span><span class="o">:</span><span class="s2">&quot;bold&quot;</span><span class="p">}</span>
<span class="p">},</span>
<span class="p">[</span><span class="s2">&quot; This is bold text shown in red &quot;</span><span class="p">]</span>
<span class="p">]]</span>
</pre></div>
</div>
<p>which is equivalent to</p>
<div class="highlight-html"><div class="highlight"><pre><span class="nt">&lt;span</span> <span class="na">id=</span><span class="s">&quot;mySpan&quot;</span> <span class="na">style=</span><span class="s">&quot;color: red; font-weight: bold;&quot;</span><span class="nt">&gt;</span>
This is bold text shown in red
<span class="nt">&lt;/span&gt;</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h4>Previous topic</h4>
<p class="topless"><a href="api/object.html"
title="previous chapter">The MathJax Object-Oriented Programming Model</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="CSS-styles.html"
title="next chapter">CSS Style Objects</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="CSS-styles.html" title="CSS Style Objects"
>next</a> |</li>
<li class="right" >
<a href="api/object.html" title="The MathJax Object-Oriented Programming Model"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

BIN
docs/html/_images/mt_head.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 28 KiB

BIN
docs/html/_images/mt_menu.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

BIN
docs/html/_images/mt_templates.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

BIN
docs/html/_images/wp_menu.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 7.1 KiB

BIN
docs/html/_images/wp_templates.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 6.9 KiB

81
docs/html/_sources/CSS-styles.txt
View File

@ -1,81 +0,0 @@
.. _css-style-objects:
*****************
CSS Style Objects
*****************
Many MathJax components allow you to specify CSS styles that control
the look of the elements they create. These are described using `CSS
style objects`, which are JavaScript objects that represent standard
CSS declarations. The main CSS style object is a collection of
`name:value` pairs where the `name` is the CSS selector that is being
defined, and the `value` is an object that gives the style for that
selector. Most often, the selector will need to be enclosed in
quotation marks, as it will contain special characters, so you would
need to use ``"#myID"`` rather than just ``#myID`` and ``"ul li"``
rather than just ``ul li``.
The value used to define the CSS style can either be a string
containing the CSS definition, or a javascript object that is itself a
collection of `name:value` pairs, where the `name` is the attribute
being defined and `value` is the value that attribute should be given.
Note that, since this is a JavaScript object, the pairs are separated
by commas (not semi-colons) and the values are enclosed in quotation
marks. If the name contains dashes, it should be enclosed in
quotation marks as well.
For example, ``jax/output/HTML-CSS/config.js`` includes the following
declaration:
.. code-block:: javascript
styles: {
".MathJax_Display": {
"text-align": "center",
margin: "1em 0em"
},
".MathJax .merror": {
"background-color": "#FFFF88",
color: "#CC0000",
border: "1px solid #CC0000",
padding: "1px 3px",
"font-style": "normal",
"font-size": "90%"
}
}
This defines two CSS styles, one for the selector
``.MathJax_Display``, which specifies its text alignment and margin
settings, and a second for ``.MathJax .merror``, which specifies a
background color, foreground color, border, and so on.
You can add as many such definitions to a ``styles`` object as you
wish. Note, however, that since this is a JavaScript object, the
selectors must be unique (e.g., you can't use two definitions for
``"img"``, for example, as only the last one would be saved). If you
need to use more than one entry for a single selector, you can add
comments like ``/* 1 */`` and ``/* 2 */`` to the selector to make them
unique.
It is possible to include selectors like ``"@media print"``, in which
case the value is a CSS style object. For example:
.. code-block:: javascript
styles: {
"@media print": {
".MathJax .merror": {
"background-color": "white",
border: 0
}
}
}
The various extensions and output processors include more examples of
CSS style objects, so see the code for those files for additional
samples. In particular, the ``extensions/MathMenu.js``,
``extensions/MathZoom.js``, ``extensions/FontWarnsing.js``, and
``jax/output/HTML-CSS/jax.js`` files include such definitions.

83
docs/html/_sources/HTML-snippets.txt
View File

@ -1,83 +0,0 @@
.. _html-snippets:
************************
Describing HTML snippets
************************
A number of MathJax configuration options allow you to specify an HTML
snippet using a JavaScript object. This lets you include HTML in your
configuration files even though they are not HTML files themselves.
The format is fairly simple, but flexible enough to let you represent
complicated HTML trees.
An HTML snippet is an array consisting of a series of elements that format
the HTML tree. Those elements are one of two things: either a string,
which represents text to be included in the snippet, or an array,
which represents an HTML tag to be included. In the latter case, the
array consists of three items: a string that is the tag name (e.g.,
"img"), an optional object that gives attributes for the tag (as
described below), and an optional HTML snippet array that gives the
contents of the tag.
When attributes are provided, they are given as `name:value` pairs,
with the `name` giving the attribute name, and `value` giving its
value. For example
.. code-block:: javascript
[["img",{src:"/images/mypic.jpg"}]]
represents an HTML snippet that includes one element: an ``<img>`` tag
with ``src`` set to ``/images/mypic.jpg``. That is, this is
equivalent to
.. code-block:: html
<img src="/images/mypic.jpg">
Note that the snippet has two sets of square brackets. The outermost
one is for the array that holds the snippet, and the innermost set is
because the first (and only) element in the snippet is a tag, not
text. Note that the code ``["img",{src:"/images/mypic.jpg"}]``
is invalid as an HTML snippet. It would represent a snippet that
starts with "img" as text in the snippet (not a tag), but the second
item is neither a string nor an array, and so is illegal. This is a
common mistake that should be avoided.
A more complex example is the following:
.. code-block:: javascript
[
"Please read the ",
["a",{href:"instructions.html"},["instructions"]],
" carefully before proceeding"
]
which is equivalent to
.. code-block:: html
please read the <a href="instructions.html">instructions</a> carefully
before proceeding.
A final example shows how to set style attributes on an object:
.. code-block:: javascript
[["span",
{
id:"mySpan",
style: {color:"red", "font-weight":"bold"}
},
[" This is bold text shown in red "]
]]
which is equivalent to
.. code-block:: html
<span id="mySpan" style="color: red; font-weight: bold;">
This is bold text shown in red
</span>

214
docs/html/_sources/api/ajax.txt
View File

@ -1,214 +0,0 @@
.. _api-ajax:
***********************
The MathJax.Ajax Object
***********************
The `MathJax.Ajax` structure holds the data and functions for handling
loading of external modules. Modules are loaded only once, even if
called for in several places. The loading of files is asynchronous,
and so the code that requests an external module will continue to run
even when that module has not completed loading, so it is important to
be aware of the timing issues this may cause. Similarly, creating or
loading stylesheets is an asynchronous action. In particular, all
actions that rely on the file or stylesheet having been loaded must be
delayed until after the file has been downloaded completely. This is
the reason for the large number of routines that take callback
functions.
Any operation that could cause the loading of a file or stylesheet
must be synchronized with the rest of the code via such callbacks.
Since processing any mathematics might cause files to be loaded (e.g.,
little-used markup might be implemented in an extension that is loaded
only when that markup is used), any code that dynamically typesets
mathematics will need to be structured to use callbacks to guarantee
that the mathematics has been completely processed before the code
tries to use it. See the :ref:`Synchronizing with MathJax <synchronization>`
documentation for details on how to do this properly.
Properties
==========
.. describe:: timeout
Number of milliseconds to wait for a file to load before
it is considered to have failed to load.
*Default:* 15 seconds
.. describe:: STATUS.OK
The value used to indicate that a file load has occurred
successfully.
.. describe:: STATUS.ERROR
The value used to indicate that a file load has caused an error or
a timeout to occur.
.. describe:: loaded
An object containing the names of the files that have been loaded (or
requested) so far. ``MathJax.Ajax.loaded["file"]`` will be
non-``null`` when the file has been loaded, with the value being
the ``MathJax.Ajax.STATUS`` value of the load attempt.
.. describe:: loading
An object containing the files that are currently loading, the
callbacks that are to be run when they load or timeout, and
additional internal data.
.. describe:: loadHooks
An object containing the load hooks for the various files, set up by
the :meth:`LoadHook()` method, or by the
:meth:`MathJax.Hub.Register.LoadHook()` method.
Methods
=======
.. method:: Require(file[,callback])
Loads the given file if it hasn't been already. The file must be a
JavaScript file or a CSS stylesheet; i.e., it must end in ``.js``
or ``.css``. Alternatively, it can be an object with a single
`key:value` pair where the `key` is one of ``js`` or ``css`` and
the `value` is the file of that type to be loaded (this makes it
possible to have the file be created by a CGI script, for example,
or to use a ``data::`` URL). The file must be relative to the
MathJax home directory and can not contain ``../`` file path
components.
When the file is completely loaded and run, the `callback`, if
provided, will be executed passing it the status of the file load.
If there was an error while loading the file, or if the file fails
to load within the time limit given by ``MathJax.Ajax.timout``,
the status will be ``MathJax.Ajax.STATUS.ERROR`` otherwise it
will be ``MathJax.Ajax.STATUS.OK``. If the file is already
loaded, the callback will be called immediately and the file will
not be loaded again.
:Parameters:
- **file** --- name of the file to be loaded
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Load(file[,callback])
Used internally to load a given file without checking if it
already has been loaded, or where it is to be found.
:Parameters:
- **file** --- name of the file to be loaded
- **callback** --- the callback specification
:Returns: the callback object
.. method:: loadComplete(file)
Called from within the loaded files to inform MathJax that the
file has been completely loaded and initialized. The `file`
parameter is the name of the file that has been loaded. This
routine will cause any callback functions registered for the file
or included in the :meth:`MathJax.Ajax.Require()` calls to be
executed, passing them the status of the load
(``MathJax.Ajax.STATUS.OK`` or ``MathJax.Ajax.STATUS.ERROR``) as
their last parameter.
:Parameters:
- **file** --- name of the file that has been loaded
:Returns: ``null``
.. method:: loadTimeout(file)
Called when the timeout period is over and the file hasn't loaded.
This indicates an error condition, and the
:meth:`MathJax.Ajax.loadError()` method will be executed, then the
file's callback will be run with ``MathJax.Ajax.STATUS.ERROR`` as
its parameter.
:Parameters:
- **file** --- name of the file that timed out
:Returns: ``null``
.. method:: loadError(file)
The default error handler called when a file fails to load. It
puts a warning message into the MathJax message box on screen.
:Parameters:
- **file** --- the name of the file that failed to load
:Returns: ``null``
.. method:: LoadHook(file,callback)
Registers a callback to be executed when the given file is
loaded. The file load operation needs to be started when this
method is called, so it can be used to register a hook for a file
that may be loaded in the future.
:Parameters:
- **file** --- the name of the file to wait for
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Preloading(file1[,file2...])
Used with combined configuration files to indicate what files are
in the configuration file. Marks the files as loading (since there
will never be an explicit :meth:`Load()` or :meth:`Require()` call for
them), so that load-hooks and other load-related events can be
properly processed when the :meth:`loadComplete()` occurs.
:Parameters:
- **file1, file2, ...** --- the names of the files in the combined file
:Returns: ``null``
.. method:: Styles(styles[,callback])
Creates a stylesheet from the given style data. `styles` can
either be a string containing a stylesheet definition, or an
object containing a :ref:`CSS Style Object <css-style-objects>`.
For example:
.. code-block:: javascript
MathJax.Ajax.Styles("body {font-family: serif; font-style: italic}");
and
.. code-block:: javascript
MathJax.Ajax.Styles({
body: {
"font-family": "serif",
"font-style": "italic"
}
});
both set the body font family and style.
The callback routine is called when the stylesheet has been
created and is available for use.
:Parameters:
- **styles** --- CSS style object for the styles to set
- **callback** --- the callback specification
:Returns: the callback object
.. note::
Internet Explorer has a limit of 32 dynamically created
stylesheets, so it is best to combine your styles into one
large group rather than making several smaller calls.
.. method:: fileURL(file)
Returns a complete URL to a file (replacing ``[MathJax]`` with the
actual root URL location).
:Parameters:
- **file** --- the file name possibly including ``[MathJax]``
:Returns: the full URL for the file

304
docs/html/_sources/api/callback.txt
View File

@ -1,304 +0,0 @@
.. _api-callback:
**************************
The MathJax.Callback Class
**************************
The ``MathJax.Callback`` object is one of the key mechanisms used by
MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A `Callback`
object is used to tie the execution of a function to the completion of
an asynchronous action. See :ref:`Synchronizing with MathJax
<synchronization>` for more details, and :ref:`Using Callbacks
<using-callbacks>` in particular for examples of how to specify and
use MathJax `Callback` objects.
Specifying a callback
---------------------
When a method includes a callback as one of its arguments, that
callback can be specified in a number of different ways, depending on
the functionality that is required of the callback. The easiest case
is to simply provide a function to be called, but it is also possible
to include data to pass to the function when it is executed, and even
the object that will be used as the javascript `this` object when the
function is called.
Most functions that take callbacks as arguments accept a `callback
specification` rather than an actual callback object, though you can
use the :meth:`MathJax.Callback` function to convert a callback
specification into a Callback object if needed.
A callback specification is any one of the following:
.. describe:: fn
A function that is to be called when the callback is executed.
No additional data is passed to it (other than what it is
called with at the time the callback is executed), and `this`
will be the window object.
.. describe:: [fn]
An array containing a function to be called when the callback
is executed (as above).
.. describe:: [fn, data...]
An array containing a function together with data to be passed
to that function when the callback is executed; `this` is still
the window object. For example,
.. code-block:: javascript
[function (x,y) {return x+y}, 2, 3]
would specify a callback that would pass ``2`` and ``3`` to
the given function, and it would return their sum, ``5``, when
the callback is executed.
.. describe:: [object, fn]
An array containing an object to use as `this` and a function to
call for the callback. For example,
.. code-block:: javascript
[{x:'foo', y:'bar'}, function () {this.x}]
would produce a callback that returns the string ``"foo"``
when it is called.
.. describe:: [object, fn, data...]
Similar to the previous case, but with data that is passed to
the function as well.
.. describe:: ["method", object]
Here, `object` is an object that has a method called `method`, and
the callback will execute that method (with the object as
`this`) when it is called. For example,
.. code-block:: javascript
["toString",[1,2,3,4]]
would call the `toString` method on the array ``[1,2,3,4]`` when
the callback is called, returning ``1,2,3,4``.
.. describe:: ["method", object, data...]
Similar to the previous case, but with data that is passed to
the method. E.g.,
.. code-block:: javascript
["slice",[1,2,3,4],1,3]
would perform the equivalent of ``[1,2,3,4].slice(1,3)``,
which returns the array ``[2,3]`` as a result.
.. describe:: {hook: fn, data: [...], object: this}
Here the data for the callback are given in an associative
array of `key:value` pairs. The value of `hook` is the
function to call, the value of `data` is an array of the
arguments to pass to the function, and the value of `object`
is the object to use as `this` in the function call. The
specification need not include all three `key:value` pairs; any
that are missing get default values (a function that does
nothing, an empty array, and the window object, respectively).
.. describe:: "string"
This specifies a callback where the string is executed via an
``eval()`` statement. The code is run in the global context,
so any variables or functions created by the string become
part of the global namespace. The return value is the value of
the last statement executed in the string.
Executing a Callback Object
===========================
The `Callback` object is itself a function, and calling that function
executes the callback. You can pass the callback additional
parameters, just as you can any function, and these will be added to
the callback function's argument list following any data that was
supplied at the time the callback was created. For example
.. code-block:: javascript
var f = function (x,y) {return x + " and " +y}
var cb = MathJax.Callback([f, "foo"]);
var result = cb("bar"); // sets result to "foo and bar"
Usually, the callback is not executed by the code that creates it (as
it is in the example above), but by some other code that runs at a
later time at the completion of some other activity (say the loading
of a file), or in response to a user action. For example:
.. code-block:: javascript
function f(x) {alert("x contains "+x)};
function DelayedX(time) {
var x = "hi";
setTimeout(MathJax.Callback([f, x], time));
}
The ``DelayedX`` function arranges for the function ``f`` to be called at
a later time, passing it the value of a local variable, ``x``. Normally,
this would require the use of a closure, but that is not needed when a
`MathJax.Callback` object is used.
Callback Object Properties
--------------------------
.. describe:: hook
The function to be called when the callback is executed.
.. describe:: data
An array containing the arguments to pass to the callback
function when it is executed.
.. describe:: object
The object to use as `this` during the call to the callback
function.
.. describe:: called
Set to ``true`` after the callback has been called, and undefined
otherwise. A callback will not be executed a second time unless
the callback's :meth:`reset()` method is called first, or its
``autoReset`` property is set to ``true``.
.. describe:: autoReset
Set this to ``true`` if you want to be able to call the callback
more than once. (This is the case for signal listeners, for example).
.. describe:: isCallback
Always set to ``true`` (used to detect if an object is a callback
or not).
Callback Object Methods
-----------------------
.. method:: reset()
Clears the callback's `called` property.
MathJax.Callback Methods
------------------------
.. method:: Delay(time[, callback])
Waits for the specified time (given in milliseconds) and then
performs the callback. It returns the Callback object (or a blank
one if none was supplied). The returned callback structure has a
`timeout` property set to the result of the ``setTimeout()`` call
that was used to perform the wait so that you can cancel the wait,
if needed. Thus :meth:`MathJax.Callback.Delay()` can be used to
start a timeout delay that executes the callback if an action
doesn't occur within the given time (and if the action does occur,
the timeout can be canceled). Since
:meth:`MathJax.Callback.Delay()` returns a callback structure, it
can be used in a callback queue to insert a delay between queued
commands.
:Parameters:
- **time** --- the amount of time to wait
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Queue([callback,...])
Creates a `MathJax.CallBack.Queue` object and pushes the given
callbacks into the queue. See :ref:`Using Queues <using-queues>`
for more details about MathJax queues.
:Parameters:
- **callback** --- one or more callback specifications
:Returns: the `Queue` object
.. method:: Signal(name)
Looks for a named signal, creates it if it doesn't already exist,
and returns the signal object. See
:ref:`Using Signals <using-signals>` for more details.
:Parameters:
- **name** --- name of the signal to get or create
:Returns: the `Signal` object
.. method:: ExecuteHooks(hooks[, data[,reset]])
Calls each callback in the `hooks` array (or the single hook if it
is not an array), passing it the arguments stored in the data
array. If `reset` is ``true``, then the callback's
:meth:`reset()` method will be called before each hook is
executed. If any of the hooks returns a `Callback` object, then
it collects those callbacks and returns a new callback that will
execute when all the ones returned by the hooks have been
completed. Otherwise, :meth:`MathJax.Callback.ExecuteHooks()`
returns ``null``.
:Parameters:
- **hooks** --- array of hooks to be called, or a hook
- **data** --- array of arguments to pass to each hook in turn
- **reset** --- ``true`` if the :meth:`reset()` method should be called
:Returns: callback that waits for all the hooks to complete, or ``null``
.. method:: Hooks(reset)
Creates a prioritized list of hooks that are called in order based
on their priority (low priority numbers are handled first). This
is meant to replace :meth:`MathJax.Callback.ExecuteHooks()` and is
used internally for signal callbacks, pre- and post-filters, and
other lists of callbacks.
:Parameters:
- **reset** --- ``true`` if callbacks can be called more than once
:Returns: the `Hooks` object
The list has the following methods:
.. method:: Add(hook[,priority])
Add a callback to the prioritized list. If ``priority`` is
not provided, the default is 10. The ``hook`` is a `Callback`
specification as described above.
:Parameters:
- **hook** --- callback specification to add to the list
- **priority** --- priority of the hook in the list (default: 10)
:Returns: the callback object being added
.. method:: Remove(hook)
:noindex:
Remove a given hook (as returned from :meth:`Add()` above)
from the prioritized list.
:Parameters:
- **hook** --- the callback to be removed
:Returns: ``null``
.. method:: Execute()
Execute the list of callbacks, resetting them if requested.
If any of the hooks return callbacks, then ``Execute()``
returns a callback that will be executed when they all have
completed.
:Returns: a callback object or ``null``

145
docs/html/_sources/api/elementjax.txt
View File

@ -1,145 +0,0 @@
.. _api-element-jax:
****************************
The MathJax.ElementJax Class
****************************
The element jax is the bridge between the input and output jax, and
contains the data produced by the input jax needed by the output jax
to display the results. It is tied to the individual ``<script>`` tag
that produced it, and is the object used by JavaScript programs to
interact with the mathematics on the page.
An element jax is stored in the ``jax.js`` file in a subdirectory of
the ``jax/element`` directory, with the subdirectory name being the
name of the element jax. Currently, there is only one element jax
class, the `mml` element jax, and it is stored in ``jax/element/mml``.
The `MathJax.ElementJax` class is a subclass of the :ref:`MathJax Jax
<api-jax>` class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.
Class Properties
================
.. describe:: id
The name of the jax.
.. describe:: version
The version number of the jax.
.. describe:: directory
The directory where the jax files are stored (e.g., ``"[MathJax]/jax/element/mml"``).
Instance Properties
===================
.. describe:: inputJax
The name of the input jax that created the element.
.. describe:: outputJax
The name of the output jax that has processed this element.
.. describe:: inputID
The DOM `id` of the ``<script>`` tag that generated this element
(if it doesn't have one initially, the MathJax hub will supply
one). Note that this is not a reference to the element itself;
that element will have a reference to this element jax, and if
`inputID` were a reference back, that would cause a reference
loop, which some browsers would not free properly during trash
collection, thus causing a memory leak.
.. describe:: originalText
A string indicating the original input text that was processed for
this element. (In the future, this may be managed by the input jax
rather than ``MathJax.Hub``.)
.. describe:: mimeType
The MIME-type of the element jax (`jax/mml` in the case of an
`mml` element jax).
Other data specific to the element jax subclass may also appear here.
Methods
=======
.. Method:: Text(text[,callback])
Sets the input text for this element to the given text and
reprocesses the mathematics. (I.e., updates the equation to the
new one given by `text`). When the processing is complete, the
`callback`, if any, is called.
:Parameters:
- **text** --- the new mathematics source string for the element
- **callback** --- the callback specification
:Returns: the callback object
.. Method:: Rerender([callback])
:noindex:
Removes the output and produces it again (for example, if CSS has
changed that would alter the spacing of the mathematics). Note
that the internal representation isn't regenerated; only the
output is. The `callback`, if any, is called when the process
completes.
:Parameters:
- **callback** --- the callback specification
:Returns: the callback object
.. Method:: Reprocess([callback])
:noindex:
Removes the output and then retranslates the input into the
internal form and reredners the output again. The `callback`, if
any, is called when the process completes.
:Parameters:
- **callback** --- the callback specification
:Returns: the callback object
.. Method:: Remove()
:noindex:
Removes the output for this element from the web page (but does
not remove the original ``<script>``). The ``<script>`` will be
considered unprocessed, and the next call to
:meth:`MathJax.hub.Typeset()` will re-display it.
:Returns: ``null``
.. Method:: SourceElement()
Returns a reference to the original ``<script>`` DOM element
associated to this element jax.
:Returns: the ``<script>`` element
.. Method:: needsUpdate()
Indicates whether the mathematics has changed so that its output
needs to be updated.
:Returns: ``true`` if the mathematics needs to be reprocessed,
``false`` otherwise
Output jax may add new methods to the base element jax class to
perform exporting to other formats. For example, a MathML output jax
could add ``toMathML()``, or an accessibility output jax could add
``toAudible()``. These could be made available via the MathJax
contextual menu.

142
docs/html/_sources/api/html.txt
View File

@ -1,142 +0,0 @@
.. _api-html:
***********************
The MathJax.HTML Object
***********************
The ``MathJax.HTML`` object provides routines for creating HTML
elements and adding them to the page, and in particular, it contains
the code that processes MathJax's :ref:`HTML snippets <html-snippets>`
and turns them into actual DOM objects. It also implements the
methods used to manage the cookies used by MathJax.
Properties
==========
.. describe:: Cookie.prefix: "mjx"
The prefix used for names of cookies stored by MathJax.
.. describe:: Cookie.expires: 365
The expiration time (in days) for cookies created by MathJax.
Methods
=======
.. method:: Element(type[,attributes[,contents]])
Creates a DOM element of the given type. If `attributes` is
non-``null``, it is an object that contains `key:value` pairs of
attributes to set for the newly created element. If `contents` is
non-``null``, it is an :ref:`HTML snippet <html-snippets>` that
describes the contents to create for the element. For example
.. code-block:: javascript
var div = MathJax.HTML.Element(
"div",
{id: "MathDiv", style:{border:"1px solid", padding:"5px"}},
["Here is math: \\(x+1\\)",["br"],"and a display $$x+1\\over x-1$$"]
);
:Parameters:
- **type** --- node type to be created
- **attributes** --- object specifying attributes to set
- **contents** --- HTML snippet representing contents of node
:Returns: the DOM element created
.. method:: addElement(parent,type[,attributes[,content]])
Creates a DOM element and appends it to the `parent` node
provided. It is equivalent to
.. code-block:: javascript
parent.appendChild(MathJax.HTML.Element(type,attributes,content))
:Parameters:
- **parent** --- the node where the element will be added
- **attributes** --- object specifying attributes to set
- **contents** --- HTML snippet representing contents of node
:Returns: the DOM element created
.. method:: TextNode(text)
Creates a DOM text node with the given text as its content.
:Parameters:
- **text** --- the text for the node
:Returns: the new text node
.. method:: addText(parent,text)
Creates a DOM text node with the given text and appends it to the
`parent` node.
:Parameters:
- **parent** --- the node where the text will be added
- **text** --- the text for the new node
:Returns: the new text node
.. method:: setScript(script,text)
Sets the contents of the ``script`` element to be the given
``text``, properly taking into account the browser limitations and
bugs.
:Parameters:
- **script** --- the script whose content is to be set
- **text** --- the text that is to be the script's new content
:Returns: ``null``
.. method:: getScript(script)
Gets the contents of the ``script`` element, properly taking into
account the browser limitations and bugs.
:Parameters:
- **script** --- the script whose content is to be retrieved
:Returns: the text of the ``script``
.. describe:: Cookie.Set(name,data)
Creates a MathJax cookie using the ``MathJax.HTML.Cookie.prefix``
and the `name` as the cookie name, and the `key:value` pairs in
the `data` object as the data for the cookie. For example,
.. code-block:: javascript
MathJax.HTML.Cookie.Set("test",{x:42, y:"It Works!"});
will create a cookie named "mjx.test" that stores the values of
``x`` and ``y`` provided in the `data` object. This data can be
retrieved using the :meth:`MathJax.HTML.Cookie.Get()` method
discussed below.
:Parameters:
- **name** --- the name that identifies the cookie
- **data** --- object containing the data to store in the cookie
:Returns: ``null``
.. describe:: Cookie.Get(name[,obj])
Looks up the data for the cookie named `name` and merges the data
into the given `obj` object, or returns a new object containing
the data. For instance, given the cookie stored by the example
above,
.. code-block:: javascript
var data = MathJax.HTML.Cookie.Get("test");
would set ``data`` to ``{x:42, y:"It Works!"}``, while
.. code-block:: javascript
var data = {x:10, z:"Safe"};
MathJax.HTML.Cookie.Get("test",data);
would leave ``data`` as ``{x:42, y:"It Works!", z:"Safe"}``.

407
docs/html/_sources/api/hub.txt
View File

@ -1,407 +0,0 @@
.. _api-hub:
**********************
The MathJax.Hub Object
**********************
The MathJax Hub, `MathJax.Hub`, is the main control structure for
MathJax. It is where input and output :term:`jax` are tied together,
and it is what handles processing of the MathJax ``<script>`` tags.
Processing of the mathematics on the page may require external files
to be loaded (when the mathematics includes less common functionality,
for example, that is defined in an extension file), and since file
loading is asynchronous, a number of the methods below may return
before their actions are completed. For this reason, they include
callback functions that are called when the action completes. These
can be used to synchronize actions that require the mathematics to be
completed before those actions occur. See the :ref:`Using Callbacks
<using-callbacks>` documentation for more details.
Properties
==========
.. describe:: config: { ... }
This holds the configuration parameters for MathJax. Set these
values using :meth:`MathJax.Hub.Config()` described below. The
options and their default values are given in the :ref:`Core
Options <configure-hub>` reference page.
.. describe:: processUpdateTime: 250
The minimum time (in milliseconds) between updates of the
"Processing Math" message. After this amount of time has passed,
and after the next equation has finished being processed,
MathJax will stop processing momentarily so that the update
message can be displayed, and so that the browser can handle user
interaction.
.. describe:: processUpdateDelay: 10
The amount of time (in milliseconds) that MathJax pauses after
issuing its processing message before starting the processing again
(to give browsers time to handle user interaction).
.. describe:: signal
The hub processing signal (tied to the
:meth:`MathJax.Hub.Register.MessageHook()` method).
.. describe:: queue
MathJax's main processing queue. Use :meth:`MathJax.Hub.Queue()` to push
callbacks onto this queue.
.. describe:: Browser
The name of the browser as determined by MathJax. It will be one
of ``Firefox``, ``Safari``, ``Chrome``, ``Opera``, ``MSIE``,
``Konqueror``, or ``unkown``. This is actually an object with
additional properties and methods concerning the browser:
.. describe:: version
The browser version number, e.g., ``"4.0"``
.. describe:: isMac and isPC
These are boolean values that indicate whether the browser is
running on a Macintosh computer or a Windows computer. They
will both be ``false`` for a Linux computer.
.. describe:: isMobile
This is ``true`` when MathJax is running a mobile version of a
WebKit or Gecko-based browser.
.. describe:: isFirefox, isSafari, isChrome, isOpera, isMSIE, isKonqueror
These are ``true`` when the browser is the indicated one, and
``false`` otherwise.
.. describe:: versionAtLeast(version)
This tests whether the browser version is at least that given
in the `version` string. Note that you can not simply do a
numeric comparison, as version 4.10 should be considered later
than 4.9, for example. Similarly, 4.10 is different from 4.1,
for instance.
.. describe:: Select(choices)
This lets you perform browser-specific functions. Here,
`choices` is an object whose properties are the names of the
browsers and whose values are the functions to be performed.
Each function is passed one parameter, which is the
``MathJax.Hub.Browser`` object. You do not need to include
every browser as one of your choices --- only those for which you
need to do special processing. For example:
.. code-block:: javascript
MathJax.Hub.Browser.Select(
MSIE: function (browser) {
if (browser.versionAtLeast("8.0")) {... do version 8 stuff ... }
... do general MSIE stuff ...
},
Firefox: function (browser) {
if (browser.isMac) {... do Mac stuff ... }
... do general Firefox stuff
}
);
.. describe:: inputJax
An object storing the MIME types associated with the various
registered input jax (these are the types of the ``<script>`` tags
that store the math to be processed by each input jax).
.. describe:: outputJax
An object storing the output jax associate with the various
element jax MIME types for the registered output jax.
Methods
=======
.. Method:: Config(options)
Sets the configuration options (stored in ``MathJax.Hub.config``)
to the values stored in the `options` object. See
:ref:`Configuring MathJax <configuration>` for details on how this
is used and the options that you can set.
:Parameters:
- **options** --- object containing options to be set
:Returns: ``null``
.. describe:: Configured()
When ``delayStartupUntil`` is specified in the configuration file or
in the script that loads ``MathJax.js``, MathJax's startup sequence is
delayed until this routine is called. See :ref:`Configuring MathJax
<configuration>` for details on how this is used.
:Returns: ``null``
.. describe:: Register.PreProcessor(callback)
Used by preprocessors to register themselves with MathJax so that
they will be called during the :meth:`MathJax.Hub.PreProcess()`
action.
:Parameters:
- **callback** --- the callback specification for the preprocessor
:Returns: ``null``
.. describe:: Register.MessageHook(type,callback)
Registers a listener for a particular message being sent to the
hub processing signal (where `PreProcessing`, `Processing`, and
`New Math` messages are sent). When the message equals the
`type`, the `callback` will be called with the message as its
parameter.
:Parameters:
- **type** --- a string indicating the message to look for
- **callback** --- a callback specification
:Returns: ``null``
.. describe:: Register.StartupHook(type,callback)
Registers a listener for a particular message being sent to the
startup signal (where initialization and component startup
messages are sent). When the message equals the `type`, the
`callback` will be called with the message as its parameter.
See the :ref:`Using Signals <using-signals>` documentation for
more details.
:Parameters:
- **type** --- a string indicating the message to look for
- **callback** --- a callback specification
:Returns: ``null``
.. describe:: Register.LoadHook(file,callback)
Registers a callback to be called when a particular file is
completely loaded and processed. (The callback is called when the
file makes its :meth:`MathJax.Ajax.loadComplete()` call.) The
`file` should be the complete file name, e.g.,
``"[MathJax]/config/default.js"``.
:Parameters:
- **file** --- the name of the file to wait for
- **callback** --- a callback specification
:Returns: the callback object
.. Method:: Queue(callback,...)
:noindex:
Pushes the given callbacks onto the main MathJax command queue.
This synchronizes the commands with MathJax so that they will be
performed in the proper order even when some run asynchronously.
See :ref:`Using Queues <using-queues>` for more details about how
to use queues, and the MathJax queue in particular. You may
supply as many `callback` specifications in one call to the
:meth:`Queue()` method as you wish.
:Parameters:
- **callback** --- a callback specification
:Returns: the callback object for the last callback added to the queue
.. Method:: Typeset([element[,callback]])
Calls the preprocessors on the given element (or elements if it is an
array of elements), and then typesets any math elements within the
element. If no `element` is provided, the whole document is processed.
The `element` is either the DOM `id` of the element, a reference to
the DOM element itself, or an array of id's or refereneces. The
`callback` is called when the process is complete. See the
:ref:`Modifying Math <typeset-math>` section for details of how to use
this method properly.
:Parameters:
- **element** --- the element(s) whose math is to be typeset
- **callback** --- the callback specification
:Returns: the callback object
.. method:: PreProcess([element[,callback]])
Calls the loaded preprocessors on the entire document, or on the given
DOM element (or elements, if it is an array of elements). The
`element` is either the DOM `id` of the element, a reference to the
DOM element itself, or an array of id's or references. The `callback`
is called when the processing is complete.
:Parameters:
- **element** --- the element to be preprocessed
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Process([element[,callback]])
Scans either the entire document or a given DOM `element` (or array of
elements) for MathJax ``<script>`` tags and processes the math those
tags contain. The `element` is either the DOM `id` of the element to
scan, a reference to the DOM element itself, or an array of id's or
references. The `callback` is called when the processing is complete.
:Parameters:
- **element** --- the element(s) to be processed
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Update([element[,callback]])
Scans either the entire document or a given DOM element (or elements if
it is an array of elements) for mathematics that has changed since the
last time it was processed, or is new, and typesets the mathematics
they contain. The `element` is either the DOM `id` of the element to
scan, a reference to the DOM element itself, or an array of id's or
references. The `callback` is called when the processing is complete.
:Parameters:
- **element** --- the element(s) to be updated
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Reprocess([element[,callback]])
Removes any typeset mathematics from the document or DOM element
(or elements if it is an array of elements), and then processes
the mathematics again, re-typesetting everything. This may be
necessary, for example, if the CSS styles have changed and those
changes would affect the mathematics. Reprocess calls both the
input and output jax to completely rebuild the data for
mathematics. The `element` is either the DOM `id` of the element
to scan, a reference to the DOM element itself, or an array of
id's or references. The `callback` is called when the processing
is complete.
:Parameters:
- **element** --- the element(s) to be reprocessed
- **callback** --- the callback specification
:Returns: the callback object
.. method:: Rerender([element[,callback]])
Removes any typeset mathematics from the document or DOM element
(or elements if it is an array of elements), and then renders the
mathematics again, re-typesetting everything from the current
internal version (without calling the input jax again). The
`element` is either the DOM `id` of the element to scan, a
reference to the DOM element itself, or an array of id's or
references. The `callback` is called when the processing is
complete.
:Parameters:
- **element** --- the element(s) to be reprocessed
- **callback** --- the callback specification
:Returns: the callback object
.. method:: getAllJax([element])
Returns a list of all the element jax in the document or a
specific DOM element. The `element` is either the DOM `id` of the
element, or a reference to the DOM element itself.
:Parameters:
- **element** --- the element to be searched
:Returns: array of `element jax` objects
.. method:: getJaxByType(type[,element])
Returns a list of all the element jax of a given MIME-type in the
document or a specific DOM element. The `element` is either the
DOM `id` of the element to search, or a reference to the DOM
element itself.
:Parameters:
- **type** --- MIME-type of `element jax` to find
- **element** --- the element to be searched
:Returns: array of `element jax` objects
.. method:: getJaxByInputType(type[,element])
Returns a list of all the element jax associated with input
``<script>`` tags with the given MIME-type within the given DOM
element or the whole document. The `element` is either the DOM
`id` of the element to search, or a reference to the DOM element
itself.
:Parameters:
- **type** --- MIME-type of input (e.g., ``"math/tex"``)
- **element** --- the element to be searched
:Returns: array of `element jax` objects
.. method:: getJaxFor(element)
Returns the element jax associated with a given DOM
element. If the element does not have an associated element jax,
``null`` is returned. The `element` is either the DOM `id` of the
element, or a reference to the DOM element itself.
:Parameters:
- **element** --- the element whose element jax is required
:Returns: `element jax` object or ``null``
.. method:: isJax(element)
Returns ``0`` if the element is not a ``<script>`` that can be
processed by MathJax or the result of an output jax, returns ``-1``
if the element is an unprocessed ``<script>`` tag that could be
handled by MathJax, and returns ``1`` if the element is a processed
``<script>`` tag or an element that is the result of an output jax.
:Parameters:
- **element** --- the element to inspect
:Returns: integer (-1, 0, 1)
.. Method:: setRenderer(renderer[,type])
Sets the output jax for the given element jax ``type`` (or ``jax/mml``
if none is specified) to be the one given by ``renderer``, which
must be the name of a renderer, such as ``NativeMML`` or
``HTML-CSS``. Note that this does not cause the math on the page
to be rerendered; it just sets the renderer for output in the
future (call :meth:``Rerender()`` above to replace the current
renderings by new ones).
:Parameters:
- **renderer** --- the name of the output jax to use for rendering
- **type** --- the element jax MIME type whose renderer to set
:Returns: ``null``
.. Method:: Insert(dst,src)
Inserts data from the `src` object into the `dst` object. The
`key:value` pairs in `src` are (recursively) copied into `dst`, so
that if `value` is itself an object, its content is copied into
the corresponding object in `dst`. That is, objects within `src`
are merged into the corresponding objects in `dst` (they don't
replace them).
:Parameters:
- **dst** --- the destination object
- **src** --- the source object
:Returns: the modified destination object
.. Method:: formatError(script,error)
This is called when an internal error occurs during the processing
of a math element (i.e., an error in the MathJax code itself).
The `script` is a reference to the ``<script>`` tag where the
error occurred, and `error` is the ``Error`` object for the error.
The default action is to insert an HTML snippet at the location of
the script, but this routine can be overriden during MathJax
configuration in order to perform some other action.
``MathJax.Hub.lastError`` holds the ``error`` value of the last
error on the page.
:Parameters:
- **script** --- the ``<script>`` tag causing the error
- **error** --- the ``Error`` object for the error
:Returns: ``null``

46
docs/html/_sources/api/index.txt
View File

@ -1,46 +0,0 @@
.. _mathjax-api:
===============
The MathJax API
===============
The following links document the various components that make up
MathJax. These are implemented as JavaScript objects contained within
the single global variable, ``MathJax``. Although JavaScript includes
an object system with some inheritance capabilities, they do not
constitute a full object-oriented programming model, so MathJax
implements its own object library. This means there is an ambiguity
when we speak of an "object", as it could be either a native
JavaScript object, or a MathJax object. When the distinction is
importat, we will use `Object` (capitalized) or `MathJax.Object` for
the latter; the javascript object will always be listed in lower
case.
You may also want to view the :ref:`advanced topics <advanced-topics>`
on the main MathJax documentation page.
.. toctree::
:maxdepth: 1
The MathJax variable <variable>
The MathJax.Hub object <hub>
The MathJax.Ajax object <ajax>
The MathJax.Message object <message>
The MathJax.HTML object <html>
The MathJax.CallBack class <callback>
The MathJax.CallBack.Queue class <queue>
The MathJax.CallBack.Signal class <signal>
.. toctree::
:maxdepth: 1
The MathJax.InputJax class <inputjax>
The MathJax.OutputJax class <outputjax>
The MathJax.ElementJax class <elementjax>
The base Jax class <jax>
.. toctree::
:maxdepth: 1
The MathJax Object-Oriented Programming Model <object>

130
docs/html/_sources/api/inputjax.txt
View File

@ -1,130 +0,0 @@
.. _api-input-jax:
**************************
The MathJax.InputJax Class
**************************
Input jax are the components of MathJax that translate
mathematics from its original format (like :term:`TeX` or
:term:`MathML`) to the MathJax internal format (an `element jax`).
An input jax is stored as a pair of files in a subdirectory of the
``jax/input`` directory, with the subdirectory name being the name of
the input jax. For example, the TeX input jax is stored in
`jax/input/TeX`. The first file, ``config.js``, is loaded when
MathJax is being loaded and configured, and is indicated by listing
the input jax directory in the `jax` array of the MathJax
configuration. The ``config.js`` file creates a subclass of the
`MathJax.InputJax` object for the new input jax and registers that
with MathJax, along with the MIME-type that will be used to indicate
the mathematics that is to be processed by the input jax.
The main body of the input jax is stored in the second file,
``jax.js``, which is loaded when the input jax is first called on to
translate some mathematics. This file augments the original input jax
subclass with the additional methods needed to do the translation.
MathJax calls the input jax's :meth:`Translate()` method when it needs
the input jax to translate the contents of a math ``<script>`` tag.
The `MathJax.InputJax` class is a subclass of the :ref:`MathJax Jax
<api-jax>` class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.
Properties
==========
.. describe:: id
The name of the jax.
.. describe:: version
The version number of the jax.
.. describe:: directory
The directory where the jax files are stored (e.g., ``"[MathJax]/jax/input/TeX"``).
.. describe:: elementJax
The name of the ElementJax class that this input jax will produce
(typically ``mml``, as that is the only ElementJax at the moment).
Methods
=======
.. Method:: Process(script,state)
:noindex:
This is the method that the ``MathJax.Hub`` calls when it needs
the input jax to process the given math ``<script>``. Its default
action is to do the following:
1. Start loading any element jax specified in the ``elementJax`` array;
2. Start loading the jax's ``jax.js`` file;
3. Start loading the required output jax (so it is ready when needed); and
4. Redefine itself to simply return the callback for the load operation
(so that further calls to it will cause the processing to wait for the
callback).
Once the ``jax.js`` file has loaded, this method is replaced by
the jax's ``Translate()`` method (see below), so that
subsequent calls to ``Process()`` will perform the appropriate
translation.
:Parameters:
- **script** --- reference to the DOM ``<script>`` object for
the mathematics to be translated
- **state** --- a structure containing information about the
current proccessing state of the mathematics
(internal use)
:Returns: an `ElementJax` object, or ``null``
.. Method:: Translate(script,state)
:noindex:
This is the main routine called by MathJax when a ``<script>`` of the
appropriate type is found. The default :meth:`Translate()` method
throws an error indicating that :meth:`Translate()` hasn't been
defined, so when the ``jax.js`` file loads, it should override the
default :meth:`Translate()` with its own version that does the actual
translation.
The translation process should include the creation of an
:ref:`Element Jax <api-element-jax>` that stores the data needed
for this element.
:Parameters:
- **script** --- the ``<script>`` element to be translated
- **state** --- a structure containing information about the
current proccessing state of the mathematics
(internal use)
:Returns: the `element jax` resulting from the translation
.. Method:: Register(mimetype)
:noindex:
This registers the MIME-type associated with this input jax so
that MathJax knows to call this input jax when it sees a
``<script>`` of that type. An input jax can register more than
one type, but it will be responsible for distinguishing elements
of the various types from one another.
:Parameters:
- **mimetype** --- the MIME-type of the input this jax processes
:Returns: ``null``
.. Method:: needsUpdate(jax)
:noindex:
This implements the element jax's ``needsUpdate()`` method, and
returns ``true`` if the ``jax`` needs to be rerendered (i.e., the
text has changed), and ``false`` otherwise.
:Perameters:
- **jax** --- the element jax to be checked
:Returns: ``true`` if the jax's text has changed, ``false`` otherwise

146
docs/html/_sources/api/jax.txt
View File

@ -1,146 +0,0 @@
.. _api-jax:
******************
The Base Jax Class
******************
The `MathJax.InputJax`, `MathJax.OutputJax` and `MathJax.ElementJax`
classes are all subclasses of the base `Jax` class in MathJax. This
is a private class that implements the methods common to all three
other jax classes.
Unlike most MathJax.Object classes, calling the class object creates a
*subclass* of the class, rather than an instance of the class. E.g.,
.. code-block:: javascript
MathJax.InputJax.MyInputJax = MathJax.InputJax({
id: "MyInputJax",
version: "1.0",
...
});
creates ``MathJax.InputJax.MyInputJax`` as a subclass of ``MathJax.InputJax``.
Class Properties
================
.. describe:: directory
The name of the jax directory (usually ``"[MathJax]/jax"``).
Overridden in the subclass to be the specific directory for the
class, e.g. ``"[MathJax]/jax/input"``.
.. describe:: extensionDir
The name of the extensions directory (usually ``"[MathJax]/extensions"``).
Instance Properties
===================
.. describe:: id
The name of the jax.
.. describe:: version
The version number of the jax.
.. describe:: directory
The directory for the jax (e.g., ``"[MathJax]/jax/input/TeX"``).
.. describe:: require: null
An array of files to load before the ``jax.js`` file calls the
:meth:`MathJax.Ajax.loadComplete()` method.
.. describe:: config: {}
An object that contains the default configuration options for the
jax. These can be modified by the author by including a
configuration subsection for the specific jax in question.
.. describe:: JAXFILE: "jax.js"
The name of the file that contains the main code for the jax.
Methods
=======
.. Method:: Translate(script)
This is a stub for a routine that should be defined by the jax's
``jax.js`` file when it is loaded. It should perform the translation
action for the specific jax. For an input jax, it should return the
`ElementJax` object that it created. The :meth:`Translate()` method is
never called directly by MathJax; during the ``loadComplete()``
call, this function is copied to the :meth:`Process()` method, and is
called via that name. The default :meth:`Translate()` method throws an
error indicating that the :meth:`Translate()` method was not
redefined. That way, if the ``jax.js`` file fails to load for some
reason, you will receive an error trying to process mathematics with
this jax.
:Parameters:
- **script** --- reference to the DOM ``<script>`` object for
the mathematics to be translated
:Returns: an `ElementJax` object, or ``null``
.. Method:: Register(mimetype)
This method is overridden in the `InputJax`, `OutputJax` and
`ElementJax` subclasses to handle the registration of those
classes of jax.
:Parameters:
- **mimetype** --- the MIME-type to be associated with the jax
:Returns: ``null``
.. Method:: Config()
:noindex:
Inserts the configuration block for this jax from the author's
configuration specification into the jax's ``config`` property.
If the configuration includes an ``Augment`` object, that is used
to augment the jax (that is, the configuration can override the
methods of the object, as well as the data). This is called
automatically during the loading of the ``jax.js`` file.
.. Method:: Startup()
This is a method that can be overridden in the subclasses to
perform initialization at startup time (after the configuration
has occurred).
.. Method:: loadComplete (file)
:noindex:
This is called by the ``config.js`` and ``jax.js`` files when they
are completely loaded and are ready to signal that fact to
MathJax. For ``config.js``, this simply calls the
:meth:`MathJax.Ajax.loadComplete()` method for the ``config.js``
file. For ``jax.js``, the actions performed here are the
following:
1. Post the "[name] Jax Config" message to the startup signal.
2. Perform the jax's :meth:`Config()` method.
3. Post the "[name] Jax Require" message to the startup signal.
4. Load the files from the jax's ``require`` and
``config.extensions`` arrays.
5. Post the "[name] Jax Startup" message to the startup signal.
6. Perform the jax's :meth:`Startup()` method.
7. Post the "[name] Jax Ready" message to the startup signal.
8. Copy the ``preTranslate``, ``Translate``, and
``postTranslate`` functions to ``preProcess``, ``Process``,
and ``postProcess``.
9. Perform the :meth:`MathJax.Ajax.loadComplete()` call for the
``jax.js`` file.
Note that the configuration process (the :meth:`Config()` call) can
modify the ``require`` or ``config.extensions`` arrays to add more
files that need to be loaded, and that the :meth:`Startup()` method
isn't called until those files are completely loaded.

119
docs/html/_sources/api/message.txt
View File

@ -1,119 +0,0 @@
.. _api-message:
**************************
The MathJax.Message Object
**************************
The ``MathJax.Message`` object contains the methods used to manage the
small message area that appears at the lower-left corner of the
window. MathJax uses this area to inform the user of time-consuming
actions, like loading files and fonts, or how far along in the
typesetting process it is.
The page author can customize the look of the message window by
setting styles for the ``#MathJax_Message`` selector (which can be
set via
.. code-block:: javascript
MathJax.Hub.Config({
styles: {
"#MathJax_Message": {
...
}
}
});
Because of a bug in Internet Explorer, in order to change the side of
the screen where the message occurs, you must also set the side
for ``#MathJax_MSIE_Frame``, as in
.. code-block:: javascript
MathJax.Hub.Config({
styles: {
"#MathJax_Message": {left: "", right: 0},
"#MathJax_MSIE_Frame": {left: "", right: 0}
}
});
It is possible that a message is already being displayed when another
message needs to be posted. For this reason, when a message is
displayed on screen, it gets an id number that is used when you want
to remove or change that message. That way, when a message is
removed, the previous message (if any) can be redisplayed if it hasn't
been removed. This allows for intermittent messages (like file
loading messages) to obscure longer-term messages (like "Processing
Math" messages) temporarily.
Methods
=======
.. method:: Set(message,[n,[delay]])
This sets the message being displayed to the given `message`
string. If `n` is not ``null``, it represents a message id
number and the text is set for that message id, otherwise a new id
number is created for this message. If `delay` is provided, it is
the time (in milliseconds) to display the message before it is
cleared. If `delay` is not provided, the message will not be
removed automatically; you must call the
:meth:`MathJax.Messsage.Clear()` method by hand to remove it.
:Parameters:
- **message** --- the text to display in the message area
- **n** --- the message id number
- **delay** --- amout of time to display the message
:Returns: the message id number for this message.
.. method:: Clear(n[,delay])
This causes the message with id `n` to be removed after the given
`delay`, in milliseconds. The default delay is 600 milliseconds.
:Parameters:
- **n** --- the message id number
- **delay** --- the delay before removing the message
:Returns: ``null``
.. method:: Remove()
This removes the message frame from the window (it will reappear when
future messages are set, however).
:Returns: ``null``
.. method:: File(file)
This sets the message area to a "Loading *file*" message, where *file*
is the name of the file (with ``[MathJax]`` representing the root
directory).
:Parameters:
- **file** --- the name of the file being loaded
:Returns: the message id number for the message created
.. method:: filterText(text,n)
This method is called on each message before it is displayed. It can
be used to modify (e.g., shorten) the various messages before they are
displayed. The default action is to check if the ``messageStyle``
configuration parameter is ``simple``, and if so, convert loading and
processing messages to a simpler form. This method can be overridden
to perform other sanitization of the message strings.
:Parameters:
- **text** --- the text of the message to be posted
- **n** --- the id number of the message to be posted
:Returns: the modified message text
.. method:: Log()
Returns a string of all the messages issued so far, separated by
newlines. This is used in debugging MathJax operations.
:Returns: string of all messages so far

210
docs/html/_sources/api/object.txt
View File

@ -1,210 +0,0 @@
.. _api-object:
*********************************************
The MathJax Object-Oriented Programming Model
*********************************************
MathJax uses an object-oriented programming model for its main
components, such as the `Input jax`, `Output jax`, and `Element jax`.
The model is intended to be light-weight and is based on JavaScript's
prototype inheritance mechanism. Object classes are created by making
subclasses of `MathJax.Object` or one of its subclasses, and are
instantiated by calling the object class as you would a function.
For example:
.. code-block:: javascript
MathJax.Object.Foo = MathJax.Object.Subclass({
Init: function (x) {this.setX(x)},
getX: function () {return this.x},
setX: function (x) {this.x = x}
});
var foo = MathJax.Object.Foo("bar");
foo.getX(); // returns "bar"
foo.setX("foobar");
foo.getX(); // returns "foobar"
Object classes can have static properties and methods, which are
accessed via the object class variable. E.g.,
``MathJax.Object.Foo.SUPER`` or ``MathJax.Object.Foo.Augment()`` for
the object in the example above. Static values are not inherited by
subclasses.
Static Properties
=================
.. describe:: SUPER
Pointer to the super class for this subclass. (It is a reference to
`MathJax.Object` in the example above.)
Static Methods
==============
.. method:: Subclass(def[,static])
Creates a subclass of the given class using the contents of the
`def` object to define new methods and properties of the object
class, and the contents of the optional `static` object to define
new static methods and properties.
:Parameters:
- **def** --- object that defines the properties and methods
- **static** --- object that defines static properties and methods
:Returns: the new object class
.. method:: Augment(def[,static])
Adds new properties and methods to the class prototype. All
instances of the object already in existence will receive the new
properties and methods automatically.
:Parameters:
- **def** --- object that defines the properties and methods
- **static** --- object that defines static properties and methods
:Returns: the object class itself
Properties
==========
.. describe:: constructor
Pointer to the constructor function for this class. E.g.,
``foo.constructor`` would be a reference to ``MathJax.Object.Foo``
in the example above.
Methods
=======
.. method:: Init([data])
An optional function that is called when an instance of the class
is created. When called, the `this` variable is set to the newly
instantiated object, and the `data` is whatever was passed to the
object constructor. For instance, in the example above, the
variable ``foo`` is created by calling
``MathJax.Object.Foo("bar")``, which calls the
``MathJax.Object.Foo`` object's :meth:`Init()` method with `data`
equal to ``"bar"``. If desired, the :meth:`Init()` method can
create a *different* object, and return that, in which case this
becomes the return value for the object constructor.
:Parameters:
- **data** --- the data from the constructor call
:Returns: ``null`` or the object to be returned by the constructor
.. method:: isa(class)
Returns ``true`` if the object is an instance of the given class,
or of a subclass of the given class, and ``false`` otherwise. So
using the ``foo`` value defined above,
.. code-block:: javascript
foo.isa(MathJax.Object); // returns true
foo.isa(MathJax.Object.Foo); // returns true
foo.isa(MathJax.InputJax); // returns false
.. method:: can(method)
Checks if the object has the given `method` and returns ``true``
if so, otherwise returns ``false``. This allows you to test if an
object has a particular function available before trying to call
it (i.e., if an object implements a particular feature). For example:
.. code-block:: javascript
foo.can("getX"); // returns true
foo.can("bar"); // returns false
.. method:: has(property)
Checks if the object has the given `property` and returns ``true``
if so, otherwise returns ``false``. This allows you to test if an
object has a particular property available before trying to use
it. For example:
.. code-block:: javascript
foo.has("getX"); // returns true
foo.has("x"); // returns true
foo.has("bar"); // returns false
Accessing the Super Class
=========================
If a subclass overrides a method of its parent class, it may want to
call the original function as part of its replacement method. The
semantics for this are a bit awkward, but work efficiently. Within a
method, the value ``arguments.callee.SUPER`` refers to the super
class, so you can access any method of the superclass using that. In
order to have `this` refer to the current object when you call the
super class, however, you need to use ``call()`` or
``apply()`` to access the given method.
For example, ``arguments.callee.SUPER.method.call(this,data)`` would
call the superclass' `method` and pass it `data` as its argument,
properly passing the current object as `this`. Alternatively, you can
use ``this.SUPER(arguments)`` in place of ``arguments.callee.SUPER``.
It is also possible to refer to the super class explicitly rather than
through ``arguments.callee.SUPER``, as in the following example:
.. code-block:: javascript
MathJax.Class1 = MathJax.Object.Subclass({
Init: function(x) {this.x = x},
XandY: function(y) {return "Class1: x and y = " + this.x + " and " + y}
});
MathJax.Class2 = MathJax.Class1.Subclass({
XandY: function (y) {return "Class2: "+arguments.callee.SUPER.XandY.call(this,y)}
});
MathJax.Class3 = MathJax.Class2.Subclass({
XandY: function (y) {return "Class3: "+MathJax.Class2.prototype.XandY.call(this,y)}
});
MathJax.Class4 = MathJax.Class1.Subclass({
XandY: function (y) {return "Class4: "+this.SUPER(arguments).XandY.call(this,y)}
});
var foo = MathJax.Class2("foo");
foo.XandY("bar"); // returns "Class2: Class1: x and y = foo and bar"
var bar = MathJax.Class3("bar");
bar.XandY("foo"); // returns "Class3: Class2: Class1: x and y = bar and foo"
var moo = MathJax.Class4("moo");
moo.XandY("cow"); // returns "Class4: Class1: x and y = moo and cow"
Since both of these mechanisms are rather awkward, MathJax provides an
alternative syntax that is easier on the programmer, but at the cost
of some inefficiency in creating the subclass and in calling methods
that access the super class.
Since most calls to the super class are to the overridden method, not
to some other method, the method name and the ``call()`` are
essentially redundant. You can get a more convenient syntax by
wrapping the `def` for the :meth:`Subclass()` call in a call to
``MathJax.Object.SimpleSUPER()``, as in the following example:
.. code-block:: javascript
MathJax.Class1 = MathJax.Object.Subclass({
Init: function (x) {this.x = x},
XandY: function (y) {return "Class1: x and y = " + this.x + " and " + y}
});
MathJax.Class2 = MathJax.Class1.Subclass(
MathJax.Object.SimpleSUPER({
XandY: function (y) {return "Class2: "+this.SUPER(y)},
AnotherMethod: function () {return this.x} // it's OK if a method doesn't use SUPER
})
);
var foo = MathJax.Class2("foo");
foo.XandY("bar"); // returns "Class2: Class1: x and y = foo and bar"

218
docs/html/_sources/api/outputjax.txt
View File

@ -1,218 +0,0 @@
.. _api-output-jax:
***************************
The MathJax.OutputJax Class
***************************
Output jax are the components of MathJax that translate
mathematics from the MathJax internal format (an `element jax`)
to whatever output is required to represent the mathematics (e.g.,
MathML elements, or HTML-with-CSS that formats the mathematics on screen).
An output jax is stored as a pair of files in a subdirectory of the
the ``jax/output`` directory, with the subdirectory name being the
name of the output jax. For example, the NativeMML output jax is
stored in `jax/output/NativeMML`. The first file, ``config.js``, is
loaded when MathJax is being loaded and configured, and is indicated
by listing the input jax directory in the `jax` array of the MathJax
configuration. The ``config.js`` file creates a subclass of the
`MathJax.OutputJax` object for the new output jax and registers it
with MathJax, along with the MIME-type of the element jax that it can
process.
The main body of the output jax is stored in the second file, ``jax.js``,
which is loaded when the output jax is first called on to translate
some mathematics. This file augments the original output jax
subclass with the additional methods needed to produce the output.
MathJax calls the input jax's :meth:`Translate()` method when it needs
the output jax to translate an element jax to produce output.
The `MathJax.OutputJax` class is a subclass of the :ref:`MathJax Jax
<api-jax>` class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.
Properties
==========
.. describe:: id
The name of the jax.
.. describe:: version
The version number of the jax.
.. describe:: directory
The directory where the jax files are stored (e.g., ``"[MathJax]/jax/output/HTML-CSS"``);
.. describe:: fontDir
The directory where the fonts are stored (e.g., ``"[MathJax]/fonts"``)
.. describe:: imageDir
The directory where MathJax images are found (e.g. ``"[MathJax]/images"``)
Methods
=======
.. Method:: preProcess(state)
This is called by ``MathJax.Hub`` to ask the output processor to
prepare to process math scripts. Its default action is to start
loading the jax's ``jax.js`` file, and redefine itself to simply
return the callback for the load operation (so that further calls
to it will cause the processing to wait for the callback).
Once the ``jax.js`` file has loaded, this method is replaced by
the jax's :meth:`preTranslate()` method, so that subsequent calls
to :meth:`preProcess()` will perform the appropriate translation.
:Parameters:
- **state** --- a structure containing information about the
current proccessing state of the mathematics
:Returns: ``null``
.. Method:: preTranslate(state)
This routine replaces :meth:`preProcess()` above when the jax's
``jax.js`` file is loaded. It is called by ``MathJax.Hub`` to ask
the output processor to prepare to process math scripts. (For
example, the HTML-CSS output jax uses this to determine em-sizes
for all the mathematics at once, to minimize page reflows that
slow down Internet Explorer.)
The routine can use ``state.jax[this.id]`` to obtain the array of
element jax that are to be processed. The output jax can use the
``state`` variable to maintain its own state information, but
any properties that it adds to the variable should have a prefix
that is the output jax's ID. For example, the HTML-CSS output jax
might use ``state.HTMLCSSlast`` to keep track of the last equation
it processed, or could add ``state.HTMLCSS = {...}`` to create an
object of its own within the state variable.
:Parameters:
- **state** --- a structure containing information about the
current proccessing state of the mathematics
:Returns: ``null``
.. Method:: Translate(script,state)
:noindex:
This is the main routine called by MathJax when an element jax is
to be converted to output. The default :meth:`Translate()`
method throws an error indicating that :meth:`Translate()` hasn't been
defined, so when the ``jax.js`` file loads, it should override the
default :meth:`Translate()` with its own version that does the actual
translation.
You should use ``MathJax.Hub.getJaxFor(script)`` to obtain the
element jax for the given script. The translation process may
modify the element jax (e.g., if it has data that needs to be
stored with the jax), and may insert DOM elements into the
document near the jax's ``<script>`` tag. The output jax can use
the ``state`` variable to maintain information about its
processing state, but see :meth:`preTranslate()` above for naming
conventions for properties that are added.
:Parameters:
- **script** --- the ``<script>`` element to be translated
- **state** --- a structure containing information about the
current proccessing state of the mathematics
:Returns: the `element jax` resulting from the translation
.. Method:: postTranslate(state)
This routines is called by ``MathJax.Hub`` when the translation
of math elements is complete, and can be used by the output
processor to finalize any actions that it needs to complete.
(For example, making the mathematics visible, or forcing a reflow
of the page.)
The routine can use ``state.jax[this.id]`` to obtain the array of
element jax that were processed, or can use the ``state`` variable
to store its own state information (see :meth:`preProcess()`
above for caveats about naming properties).
:Parameters:
- **state** --- a structure containing information about the
current proccessing state of the mathematics
:Returns: ``null``
.. Method:: Register(mimetype)
:noindex:
This registers the MIME-type for the element jax associated with
this output jax so that MathJax knows to call this jax when it
wants to display an element jax of that type. Several output jax
may register for the same input jax, in which case the first one
to register will be the default one for that type.
:Parameters:
- **mimetype** --- the MIME-type of the input this jax processes
:Returns: ``null``
.. Method:: Remove(jax)
:noindex:
Removes the output associated with the given element jax. The
routine can use ``jax.SourceElement()`` to locate the ``<script>``
tag associated with the element jax.
:Parameters:
- **jax** --- the element jax whose display should be removed
:Returns: ``null``
If an output jax wants its output to handle the contextual menu item
and zooming, then it needs to tie into the event-handling code
(`MathEvents`) and the zoom-handling code (`MathZoom`). That requires
the following methods.
.. Method:: getJaxFromMath(math)
This is called by the event-handling code (`MathEvents`) to get
the element jax associated with the DOM element that caused an
event to occur. The output jax will have attached event handlers
to some DOM element that is part of its output, and the
`MathEvents` code uses this routine to map back to the jax
associated with that output.
:Parameters:
- **math** --- a DOM element that triggered a DOM event
(e.g., a mouse click)
:Returns: the `ElementJax` structure associated with the DOM element
.. Method:: Zoom(jax,span,math,Mw,Mh)
This routine is called by the zoom-handling code (`MathZoom`)
when an expression has received its zoom trigger event (e.g., a
double-click). The ``jax`` is the math that needs to be zoomed,
``span`` is a ``<span>`` element in which the zoomed version of
the math should be placed, ``math`` is the DOM element that
received the zoom trigger event, and ``Mw`` and ``Mh`` are the
maximum width and height allowed for the zoom box (the ``span``).
The return value is an object with the following properties:
- ``Y`` --- the vertical offset from the top of the ``span`` to
the baseline of the mathematics
- ``mW`` --- the width of the original mathematics element
- ``mH`` --- the height of the original mathematics element
- ``zW`` --- the width of the zoomed math
- ``zH`` --- the height of the zoomed math
All of these values are in pixels.
:Parameters:
- **jax** --- the jax to be zoomed
- **span** --- the ``<span>`` in which to place the zoomed math
- **math** --- the DOM element generating the zoom event
- **Mw** --- the maximum width of the zoom box
- **Mh** --- the maximum height of the zoom box
:Returns: a structure as described above

99
docs/html/_sources/api/queue.txt
View File

@ -1,99 +0,0 @@
.. _api-queue:
********************************
The MathJax.Callback.Queue Class
********************************
The ``MathJax.Callback.Queue`` object is one of the key mechanisms
used by MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A `Queue` object
is used to coordinate a sequence of actions so that they are performed
one after another, even when one action has to wait for an
asynchronous process to complete. This guarantees that operations are
performed in the right order even when the code must wait for some
other action to occur. See :ref:`Synchronizing with MathJax
<synchronization>` for more details, and :ref:`Using Queues
<using-queues>` in particular for examples of how to specify and use
MathJax `Queue` objects.
Properties
----------
.. describe:: pending
This is non-zero when the queue is waiting for a command to
complete, i.e. a command being processed returns a `Callback`
object, indicating that the queue should wait for that action to
complete before processing additional commands.
.. describe:: running
This is non-zero when the queue is executing one of the commands in
the queue.
.. describe:: queue
An array containing the queued commands that are yet to be performed.
Methods
-------
.. method:: Push(callback,...)
Adds commands to the queue and runs them (if the queue is not
pending or running another command). If one of the callbacks is
an actual `Callback` object rather than a callback specification,
then the command queued is an internal command to wait for the
given callback to complete. That is, that callback is not itself
queued to be executed, but a wait for that callback is queued.
The :meth:`Push()` method returns the last callback that was
added to the queue (so that it can be used for further
synchronization, say as an entry in some other queue).
:Parameters:
- **callback** --- the callback specifications to be added to the queue
:Returns: the last callback object added to the queue
.. method:: Process()
:noindex:
Process the commands in the queue, provided the queue is not
waiting for another command to complete. This method is used
internally; you should not need to call it yourself.
.. method:: Suspend()
Increments the `running` property, indicating that any commands that
are added to the queue should not be executed immediately, but should
be queued for later execution (when its :meth:`Resume()` is
called). This method is used internally; you should not need to
call it yourself.
.. method:: Resume()
Decrements the `running` property, if it is positive. When it is
zero, commands can be processed, but that is not done
automatically --- you would need to call :meth:`Process()` to make
that happen. This method is used internally; you should not need
to call it yourself.
.. method:: wait(callback)
Used internally when an entry in the queue is a `Callback` object
rather than a callback specification. A callback to this function
(passing it the original callback) is queued instead, and it
simply returns the callback it was passed. Since the queue will
wait for a callback if it is the return value of one of the
commands it executes, this effectively makes the queue wait for the
original callback at that point in the command queue.
:Parameters:
- **callback** --- the function to complete before returning to the queue
:Returns: the passed callback function
.. method:: call()
An internal function used to restart processing of the queue after
it has been waiting for a command to complete.

154
docs/html/_sources/api/signal.txt
View File

@ -1,154 +0,0 @@
.. _api-signal:
*********************************
The MathJax.Callback.Signal Class
*********************************
The ``MathJax.Callback.Signal`` object is one of the key mechanisms
used by MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A `Signal` object
is used to publicize the fact that MathJax has performed certain
actions, giving other code running the web page the chance to react to
those actions. See :ref:`Synchronizing with MathJax
<synchronization>` for more details, and :ref:`Using Signals
<using-signals>` in particular for examples of how to specify and use
MathJax `Signal` objects.
The `Callback Signal` object is a subclass of the :ref:`Callback Queue
<api-queue>` object.
Properties
----------
.. describe:: name
The name of the signal. Each signal is named so that
various components can access it. The first one to request a
particular signal causes it to be created, and other requests for
the signal return references to the same object.
.. describe:: posted
Array used internally to store the post history so that when new
listeners express interests in this signal, they can be informed
of the signals that have been posted so far. This can be cleared
using the signal's :meth:`Clear()` method.
.. describe:: listeners
Array of callbacks to the listeners who have expressed interest in
hearing about posts to this signal. When a post occurs, the
listeners are called, each in turn, passing them the message that
was posted.
Methods
-------
.. method:: Post(message[,callback])
Posts a message to all the listeners for the signal. The listener
callbacks are called in turn (with the message as an argument),
and if any return a `Callback` object, the posting will be
suspended until the callback is executed. In this way, the
:meth:`Post()` call can operate asynchronously, and so the
`callback` parameter is used to synchronize with its operation;
the `callback` will be called when all the listeners have responded
to the post.
If a :meth:`Post()` to this signal occurs while waiting for the
response from a listener (either because a listener returned a
`Callback` object and we are waiting for it to complete when the
:meth:`Post()` occurred, or because the listener itself called the
``Post()`` method), the new message will be queued and will be
posted after the current message has been sent to all the
listeners, and they have all responded. This is another way in
which posting can be asynchronous; the only sure way to know that
a posting has occurred is through its `callback`. When the posting
is complete, the callback is called, passing it the signal object
that has just completed.
Returns the callback object (or a blank callback object if none
was provided).
:Parameters:
- **message** --- the message to send through the signal
- **callback** --- called after the message is posted
:Returns: the callback or a blank callback
.. method:: Clear([callback])
:noindex:
This causes the history of past messages to be cleared so new
listeners will not receive them. Note that since the signal may
be operating asynchronously, the :meth:`Clear()` may be queued for
later. In this way, the :meth:`Post()` and :meth:`Clear()`
operations will be performed in the proper order even when they
are delayed. The `callback` is called when the :meth:`Clear()`
operation is completed.
Returns the callback (or a blank callback if none is provided).
:Parameters:
- **callback** --- called after the signal history is cleared
:Returns: the callback or a blank callback
.. method:: Interest(callback[,ignorePast])
This method registers a new listener on the signal. It creates a
`Callback` object from the callback specification, attaches it to
the signal, and returns that `Callback` object. When new messages
are posted to the signal, it runs the callback, passing it the
message that was posted. If the callback itself returns a
`Callback` object, that indicates that the listener has started an
asynchronous operation and the poster should wait for that
callback to complete before allowing new posts on the signal.
If `ignorePast` is ``false`` or not present, then before
:meth:`Interest()` returns, the callback will be called with all
the past messages that have been sent to the signal.
:Parameters:
- **callback** --- called whenever a message is posted (past or present)
- **ignorePast** --- ``true`` means ignore previous messages
:Returns: the callback object
.. method:: NoInterest(callback)
This removes a listener from the signal so that no new messages
will be sent to it. The callback should be the one returned by
the original :meth:`Interest()` call that attached the listener to
the signal in the first place. Once removed, the listener will no
longer receive messages from the signal.
:Parameters:
- **callback** --- the listener to be removed from signal
:Returns: ``null``
.. method:: MessageHook(message, callback)
This creates a callback that is called whenever the signal posts
the given message. This is a little easier than having to write a
function that must check the message each time it is called.
Although the `message` here is a string, if a message posted to the
signal is an array, then only the first element of that array is
used to match against the message. That way, if a message contains an
identifier plus arguments, the hook will match the identifier and
still get called with the complete set of arguments.
Returns the `Callback` object that was produced.
:Parameters:
- **message** --- the message to look for from the signal
- **callback** --- called when the message is posted
:Returns: the callback object
.. method:: ExecuteHook(message)
Used internally to call the listeners when a particular
message is posted to the signal.
:Parameters:
- **message** --- the posted message
:Returns: ``null``

92
docs/html/_sources/api/variable.txt
View File

@ -1,92 +0,0 @@
********************
The MathJax variable
********************
MathJax has a single global variable, ``MathJax``, in which all its
data, and the data for loaded components, are stored. The MathJax
variable is a nested structure, with its top-level properties being
objects themselves.
Main MathJax Components
=======================
.. describe:: MathJax.Hub
Contains the MathJax hub code and variables, including the startup
code, the onload handler, the browser data, and so forth.
.. describe:: MathJax.Ajax
Contains the code for loading external modules and creating
stylesheets. Most of the code that causes MathJax to
operate asynchronously is handled here.
.. describe:: MathJax.Message
Contains the code to handle the intermittent message window that
periodically appears in the lower left-hand corner of the window.
.. describe:: MathJax.HTML
Contains support code for creating HTML elements dynamically from
descriptions stored in JavaScript objects.
.. describe:: MathJax.CallBack
Contains the code for managing MathJax callbacks, queues and
signals.
.. describe:: MathJax.Extension
Initially empty, this is where extensions can load their code.
For example, the `tex2jax` preprocessor creates
``MathJax.Extension.tex2jax`` for its code and variables.
.. describe:: MathJax.Menu
Initially null, this is where the MathJax contextual menu is
stored, when ``extensions/MathMenu.js`` is loaded.
.. describe:: MathJax.Object
Contains the code for the MathJax object-oriented programming model.
.. describe:: MathJax.InputJax
The base class for all input `jax` objects. Subclasses for
specific input jax are created as sub-objects of
``MathJax.InputJax``. For example, the TeX input jax loads itself
as ``MathJax.InputJax.TeX``.
.. describe:: MathJax.OutputJax
The base class for all output `jax` objects. Subclasses for
specific output jax are created as sub-objects of
``MathJax.OutputJax``. For example, the HTML-CSS output jax loads
itself as ``MathJax.OutputJax["HTML-CSS"]``.
.. describe:: MathJax.ElementJax
The base class for all element `jax` objects. Subclasses for
specific element jax are created as sub-objects of
``MathJax.ElementJax``. For example, the mml element jax loads
itself as ``MathJax.ElementJax.mml``.
Properties
==========
.. describe:: MathJax.version
The version number of the MathJax library as a whole.
.. describe:: MathJax.fileversion
The version number of the ``MathJax.js`` file specifically.
.. describe:: MathJax.isReady
This is set to ``true`` when MathJax is set up and ready to
perform typesetting actions (and is ``null`` otherwise).

127
docs/html/_sources/asciimath.txt
View File

@ -1,127 +0,0 @@
.. _AsciiMath-support:
*************************
MathJax AsciiMath Support
*************************
The support for :term:`AsciiMath` in MathJax consists of two parts:
the `asciimath2jax` preprocessor, and the `AsciiMath` input processor.
The first of these looks for mathematics within your web page
(indicated by delimiters like ```...```) and marks the mathematics for
later processing by MathJax. The AsciiMath input processor is what
converts the AsciiMath notation into MathJax's internal format, where
one of MathJax's output processors then displays it in the web page.
The AsciiMath input jax actually includes a copy of Peter Jipsen's
``ASCIIMathML.js`` file (see the `AsciiMath home page
<http://www1.chapman.edu/~jipsen/mathml/asciimath.html>`_ for
details), and is included by permission of the author. This means
that the results of MathJax's AsciiMath processing should be the same
as using the actual ``ASCIIMathML.js`` package (at least as far as the
MathML that it generates is concerned). Thanks go to David Lippman
for writing the initial version of the AsciiMath preprocessor and
input jax.
The `asciimath2jax` preprocessor can be configured to look for whatever
markers you want to use for your math delimiters. See the
:ref:`asciimath2jax configuration options <configure-asciimath2jax>` section for
details on how to customize the action of `asciimath2jax`.
The AsciiMath input processor handles conversion of your mathematical
notation into MathJax's internal format (which is essentially MathML).
The AsciiMath input processor has few configuration options (see the
:ref:`AsciiMath options <configure-AsciiMath>` section for details).
The AsciiMath input jax handles only the original ASCIIMathML notation
(from ASCIIMathML v1.4.7), not the extened LaTeXMathML notation added
in version 2.0 of ASCIIMathML, though the AsciiMath input jax does
expose the tables that define the symbols that AsciiMath processes,
and so it would be possible to extend them to include additional
symbols. In general, it is probably better to use MathJax's :ref:`TeX
input jax <TeX-support>` to handle LaTeX notation instead.
AsciiMath delimiters
====================
By default, the `asciimath2jax` preprocessor defines the back-tick
(`````) as the delimiters for mathematics in AsciiMath format. It
does **not** define ``$...$`` as math delimiters. That is because
dollar signs appear too often in non-mathematical settings, which
could cause some text to be treated as mathematics unexpectedly. For
example, with single-dollar delimiters, "... the cost is $2.50 for the
first one, and $2.00 for each additional one ..." would cause the
phrase "2.50 for the first one, and" to be treated as mathematics
since it falls between dollar signs. For this reason, if you want to
use single-dollars for AsciiMath notation, you must enable that
explicitly in your configuration:
.. code-block:: javascript
MathJax.Hub.Config({
asciimath2jax: {
delimiters: [['$','$'], ['`','`']]
}
});
Note that the dollar signs are frequently used as a delimiter for
mathematics in the :term:`TeX` format, and you can not enable the
dollar-sign delimiter for both. It is probably best to leave dollar
signs for TeX notation.
See the ``config/default.js`` file, or the :ref:`asiimath2jax
configuration options <configure-asciimath2jax>` page, for additional
configuration parameters that you can specify for the `asciimath2jax`
preprocessor, which is the component of MathJax that identifies
AsciiMath notation within the page.
AsciiMath in HTML documents
===============================
The AsciiMath syntax is descibed in the `ASCIIMathML syntax page
<http://www1.chapman.edu/~jipsen/mathml/asciimathsyntax.html>`_.
Keep in mind that your mathematics is part of an HTML document, so you
need to be aware of the special characters used by HTML as part of its
markup. There cannot be HTML tags within the math delimiters (other
than ``<BR>``) as AsciiMath-formatted math does not include HTML tags.
Also, since the mathematics is initially given as text on the page,
you need to be careful that your mathematics doesn't look like HTML
tags to the browser (which parses the page before MathJax gets to see
it). In particular, that means that you have to be careful about
things like less-than and greater-than signs (``<`` and ``>``), and
ampersands (``&``), which have special meaning to the browsers. For
example,
.. code-block:: html
... when `x<y` we have ...
will cause a problem, because the brower will think ``<y`` is the
beginning of a tag named ``y`` (even though there is no such tag in
HTML). When this happens, the browser will think the tag continues up
to the next ``>`` in the document (typically the end of the next
actual tag in the HTML file), and you may notice that you are missing
part of the text of the document. In the example above, the "``we
have ...``" will not be displayed because the browser thinks it is
part of the tag starting at ``<y``. This is one indication you can
use to spot this problem; it is a common error and should be avoided.
Usually, it is sufficient to simply put spaces around these symbols to
cause the browser to avoid them, so
.. code-block:: html
... when `x < y` we have ...
should work. Alternatively, you can use the HTML entities ``&lt;``,
``&gt;`` and ``&amp;`` to encode these characters so that the browser
will not interpret them, but MathJax will. E.g.,
.. code-block:: html
... when `x &lt; y` we have ...
Keep in mind that the browser interprets your text before MathJax
does.

228
docs/html/_sources/callbacks.txt
View File

@ -1,228 +0,0 @@
.. _using-callbacks:
***************
Using Callbacks
***************
A "callback" is a function that MathJax calls when it completes an
action that may occur asynchronously (like loading a file). Many of
MathJax's functions operate asynchronously, and MathJax uses callbacks
to allow you to synchronize your code with the action of those
functions. The `MathJax.Callback` structure manages these callbacks.
Callbacks can include not only a function to call, but also data to be
passed to the function, and an object to act as the JavaScript `this`
value in the resulting call (i.e., the object on which the callback is
to execute).
Callbacks can be collected into :ref:`Queues <using-queues>` where the
callbacks will be processed in order, with later callbacks waiting
until previous ones have completed before they are called. They are
also used with :ref:`Signals <using-signals>` as the means of
receiving information about the signals as they occur.
A number of methods in `MathJax.Hub` and `MathJax.Ajax` accept
callback specifications as arguments and return callback structures.
These routines always will return a callback even when none was
specified in the arguments, and in that case, the callback is a "do
nothing" callback. The reason for this is so that the resulting
callback can be used in a `MathJax.Callback.Queue` for synchronization
purposes, so that the actions following it in the queue will not be
performed until after the callback has been fired.
For example, the :meth:`MathJax.Ajax.Require()` method can be used to
load external files, and it returns a callback that is called when the
file has been loaded and executed. If you want to load several files
and wait for them all to be loaded before performing some action, you
can create a `Queue` into which you push the results of the
:meth:`MathJax.Ajax.Require()` calls, and then push a callback for the
action. The final action will not be performed until all the
file-load callbacks (which precede it in the queue) have been called;
i.e., the action will not occur until all the files are loaded.
Specifying a Callback
---------------------
Callbacks can be specified in a number of different ways, depending on
the functionality that is required of the callback. The easiest case
is to simply provide a function to be called, but it is also possible
to include data to pass to the function when it is called, and to
specify the object that will be used as `this` when the function is
called.
For example, the :meth:`MathJax.Ajax.Require()` method can accept a
callback as its second argument (it will be called when the file given
as the first argument is loaded and executed). So you can call
.. code-block:: javascript
MathJax.Ajax.Require("[MathJax]/config/myConfig.js",function () {
alert("My configuration file is loaded");
});
and an alert will appear when the file is loaded. An example of
passing arguments to the callback function includes the following:
.. code-block:: javascript
function loadHook (x) {alert("loadHook: "+x)}
MathJax.Ajax.Require("[MathJax]/config/myConfig.js",[loadHook,"myConfig"]);
Here, the ``loadHook()`` function accepts one argument and generates
an alert that includes the value passed to it. The callback in the
:meth:`MathJax.Ajax.Require()` call is ``[loadHook,"myConfig"]``,
which means that (the equivalent of) ``loadHook("myConfig")`` will be
performed when the file is loaded. The result should be an alert with
the text `loadHook: myConfig`.
The callback for the :meth:`MathJax.Ajax.Require()` method actually
gets called with a status value, in addition to any parameters already
included in the callback specification, that indicates whether the
file loaded successfully, or failed for some reason (perhaps the file
couldn't be found, or it failed to compile and run). So you could use
.. code-block:: javascript
MathJax.Ajax.Require("[MathJax]/config/myConfig.js",function (status) {
if (status === MathJax.Ajax.STATUS.OK) {
alert("My configuration file is loaded");
} else {
alert("My configuration file failed to load!");
}
});
to check if the file loaded properly. With additional parameters, the
example might be
.. code-block:: javascript
function loadHook (x,status) {alert("loadHook: "+x+" has status "+status)}
MathJax.Ajax.Require("[MathJax]/config/myConfig.js",[loadHook,"myConfig"]);
Note that the parameters given in the callback specification are used
first, and then additional parameters from the call to the callback
come afterward.
Callbacks to Object Methods
===========================
When you use a method of a JavaScript object, a special variable
called `this` is defined that refers to the object whose method is
being called. It allows you to access other methods or properties of
the object without knowing explicitly where the object is stored.
For example,
.. code-block:: javascript
var aPerson = {
firstname: "John",
lastname: "Smith",
showName: function () {alert(this.firstname+" "+this.lastname)}
};
creates an object that contains three items, a `firstname`, and
`lastname`, and a method that shows the person's full name in an
alert. So ``aPerson.showName()`` would cause an alert with the text
``John Smith`` to appear. Note, however that this only works if the
method is called as ``aPerson.showName()``; if instead you did
.. code-block:: javascript
var f = aPerson.showName; // assign f the function from aPerson
f(); // and call the function
the association of the function with the data in ``aPerson`` is lost,
and the alert will probably show ``undefined undefined``. (In this
case, ``f`` will be called with ``this`` set to the ``window``
variable, and so ``this.firstname`` and ``this.lastname`` will refer
to undefined values.)
Because of this, it is difficult to use an object's method as a
callback if you refer to it as a function directly. For example,
.. code-block:: javascript
var aFile = {
name: "[MathJax]/config/myConfig.js",
onload: function (status) {
alert(this.name+" is loaded with status "+status);
}
};
MathJax.Ajax.Require(aFile.name,aFile.onload);
would produce an alert indicating that "undefined" was loaded with a
particular status. That is because ``aFile.onload`` is a reference to
the `onload` method, which is just a function, and the association
with the `aFile` object is lost. One could do
.. code-block:: javascript
MathJax.Ajax.Require(aFile.name,function (status) {aFile.onload(status)});
but that seems needlessly verbose, and it produces a closure when one
is not really needed. Instead, MathJax provides an alternative
specification for a callback that allows you to specify both the
method and the object it comes from:
.. code-block:: javascript
MathJax.Ajax.Require(aFile.name,["onload",aFile]);
This requests that the callback should call ``aFile.onload`` as the
function, which will maintain the connection between ``aFile`` and its
method, thus preserving the correct value for `this` within the method.
As in the previous cases, you can pass parameters to the method as
well by including them in the array that specifies the callback:
.. code-block:: javascript
MathJax.Ajax.Require("filename",["method",object,arg1,arg2,...]);
This approach is useful when you are pushing a callback for one of
MathJax's Hub routines into the MathJax processing queue. For example,
.. code-block:: javascript
MathJax.Hub.Queue(["Typeset",MathJax.Hub,"MathDiv"]);
pushes the equivalent of ``MathJax.Hub.Typeset("MathDiv")`` into the
processing queue.
See the :ref:`Callback Object <api-callback>` reference pages for more
information about the valid methods of specifying a callback.
Creating a Callback Explicitly
==============================
When you call a method that accepts a callback, you usually pass it a
callback specification (like in the examples above), which *describes*
a callback (the method will create the actual `Callback` object, and
return that to you as its return value). You don't usually create
`Callback` objects directly yourself.
There are times, however, when you may wish to create a callback
object for use with functions that don't create callbacks for you.
For example, the ``setTimeout()`` function can take a function as its
argument, and you may want that function to be a method of an object,
and would run into the problem described in the previous section if
you simply passed the object's method to ``setTimeout()``. Or you
might want to pass an argument to the function called by
``setTimeout()``. (Altough the ``setTimeout()`` function can accept
additional arguements that are supposed to be passed on to the code
when it is called, some versions of Internet Explorer do not implement
that feature, so you can't rely on it.) You can use a `Callback`
object to do this, and the :meth:`MathJax.Callback()` method will
create one for you. For example,
.. code-block:: javascript
function f(x) {alert("x = "+x)}
setTimeout(MathJax.Callback([f,"Hello World!"]),500);
would create a callback that calls ``f("Hello World!")``, and
schedules it to be called in half a second.

59
docs/html/_sources/community.txt
View File

@ -1,59 +0,0 @@
*********************
The MathJax Community
*********************
If you are an active MathJax user, you may wish to become involved in
the wider community of MathJax users. The MathJax project maintains
forums where users can ask questions about how to use MathJax, make
suggestions about future features for MathJax, and present their own
solutions to problems that they have faced. There is also a
bug-tracking system where you can report errors that you have found
with MathJax in your environment.
.. _community-forums:
Forums
======
If you need help using MathJax or you have solutions you want to share, please
use the `MathJax Users Google Group
<http://groups.google.com/group/mathjax-users>`_. We try hard to answer
questions quickly, and users are welcome to help with that as well. Also, users
can post code snippets showing how they have used MathJax, so it may be a good
place to find the examples you are looking for.
If you want to discuss MathJax development, please use the `MathJax Dev Google
Group <http://groups.google.com/group/mathjax-dev>`_. We made this group
to discuss anything beyond what an end-user might be interested in, so if you
have any suggestions or questions about MathJax performance, technology, or
design, feel free to submit it to the group.
The community is only as good as the users who participate, so if
you have something to offer, please take time to make a post on one of
our groups.
.. _community-tracker:
Issue tracking
==============
Found a bug or want to suggest an improvement? Post it to our `issue tracker
<http://github.com/mathjax/MathJax/issues>`_. We monitor the tracker closely,
and work hard to respond to problems quickly.
Before you create a new issue, however, please search the issues to see if it
has already been reported. You could also be using an outdated version of
MathJax, so be sure to :ref:`upgrade your copy <getting-mathjax-git>` to verify
that the problem persists in the latest version.
.. _badge:
"Powered by MathJax"
====================
If you are using MathJax and want to show your support, please consider using
our `"Powered by MathJax" badge
<http://www.mathjax.org/community/mathjax-badge>`_.

339
docs/html/_sources/config-files.txt
View File

@ -1,339 +0,0 @@
.. _common-configurations:
*********************
Common Configurations
*********************
MathJax comes with a number of pre-defined configuration files in the
``MathJax/config`` directory. The ``default.js`` file contains nearly all
the possible configuration options together with comments explaining them,
so you can use that file to customize MathJax to your needs. Simply load
it via
.. code-block:: html
<script type="text/javascript" src="path-to-MathJax/MathJax.js?config=default"></script>
where ``path-to-MathJax`` is the URL to the MathJax directory on your
server or hard disk. If you are using MathJax from the CDN, you can
view the contents of `default.js
<http://cdn.mathjax.org/mathjax/latest/config/default.js>`_ as a
reference, but you will not be able to edit the CDN copy. It is
possible to use the CDN copy of MathJax with your own configuration
file, however; see :ref:`Using a Local Configuration File with the CDN
<local-config-files>` for details.
The remaining files in the `MathJax/config
<http://cdn.mathjax.org/mathjax/latest/config/>`_ directory are
combined configuration files that include not just configuration
parameters but also the files that MathJax would need to load for
those configurations. This means MathJax will have to load fewer
files, and since each file access requires establishing connections
over the network, it can be faster to load one larger file than
several smaller ones. See :ref:`Loading and Configuring MathJax
<loading>` for more details about how to load configurations, and how
to modify the parameters for a configuration file.
The following sections describe the contents of the combined configuration
files. Each comes in two flavors: a standard version and a "full" version.
The standard version simply defines the output processor(s) that are part
of the configuration, but doesn't load the code that implements the output
processor. The full version loads the complete output processors, so
everything that MathJax needs for the page should be loaded up front, and
there will be no delay once the page is ready to be processed. To obtain
the "full" version, add ``-full`` to the end of the configuration file
name.
The ``TeX-MML-AM_HTMLorMML`` configuration file
================================================
This configuration file is the most general of the pre-defined
configurations. It loads all the main MathJax components, including
the TeX, MathML, and AsciiMath preprocessors and input processors, the
AMSmath, AMSsymbols, noErrors, and noUndefined TeX extensions, both
the native MathML and HTML-with-CSS output processor definitions, and
the MathMenu and MathZoom extensions. It is equivalent to the
following configuration:
.. code-block:: javascript
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/HTML-CSS","output/NativeMML"],
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathMenu.js","MathZoom.js"],
TeX: {
extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
}
});
In addition, it loads the mml Element Jax, the TeX, MathML, and
AsciiMath input jax main code (not just the definition files), as well
as the `toMathML` extension, which is used by the Show Source option
in the MathJax contextual menu. The `-full` version also loads both the
HTML-CSS and NativeMML output jax main code, plus the HTML-CSS
`mtable` extension, which is normally loaded on demand.
See the :ref:`tex2jax configuration <configure-tex2jax>` section for
other configuration options for the ``tex2jax`` preprocessor, and the
:ref:`TeX input jax configuration <configure-TeX>` section for options
that control the TeX input processor.
See the :ref:`mml2jax configuration <configure-mml2jax>` section for
other configuration options for the ``mml2jax`` preprocessor, and the
:ref:`MathML input jax configuration <configure-MathML>` section for
options that control the MathML input processor.
See the :ref:`asciimath2jax configuration <configure-asciimath2jax>` section for
other configuration options for the ``asciimath2jax`` preprocessor, and the
:ref:`AsciiMath input jax configuration <configure-AsciiMath>` section for
options that control the AsciiMath input processor.
See :ref:`MathJax Output Formats <output-formats>` for more
information on the NativeMML and HTML-CSS output processors. See the
:ref:`MMLorHTML configuration <configure-MMLorHTML>` section for
details on the options that control the ``MMLorHTML`` configuration.
The ``TeX-AMS-MML_HTMLorMML`` configuration file
================================================
This configuration file is the most commonly used of the pre-defined
configurations. It loads all the main MathJax components, including
the TeX and MathML preprocessors and input processors, the AMSmath,
AMSsymbols, noErrors, and noUndefined TeX extensions, both the native
MathML and HTML-with-CSS output processor definitions, and the
MathMenu and MathZoom extensions. It is equivalent to the following
configuration:
.. code-block:: javascript
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML"],
extensions: ["tex2jax.js","mml2jax.js","MathMenu.js","MathZoom.js"],
TeX: {
extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
}
});
In addition, it loads the mml Element Jax, the TeX and MathML input
jax main code (not just the definition files), as well as the
`toMathML` extension, which is used by the Show Source option in the
MathJax contextual menu. The ``-full`` version also loads both the
HTML-CSS and NativeMML output jax main code, plus the HTML-CSS
`mtable` extension, which is normally loaded on demand.
See the :ref:`tex2jax configuration <configure-tex2jax>` section for
other configuration options for the ``tex2jax`` preprocessor, and the
:ref:`TeX input jax configuration <configure-TeX>` section for options
that control the TeX input processor.
See the :ref:`mml2jax configuration <configure-mml2jax>` section for
other configuration options for the ``mml2jax`` preprocessor, and the
:ref:`MathML input jax configuration <configure-MathML>` section for
options that control the MathML input processor.
See :ref:`MathJax Output Formats <output-formats>` for more
information on the NativeMML and HTML-CSS output processors. See the
:ref:`MMLorHTML configuration <configure-MMLorHTML>` section for
details on the options that control the ``MMLorHTML`` configuration.
The ``TeX-AMS_HTML`` configuration file
================================================
This configuration file is for sites that only use TeX format for their
mathematics, and that want the output to be as close to TeX output as
possible. This uses the HTML-CSS output jax (even when the user's browser
understands MathML). The user can still use the MathJax contextual menu
to select the NativeMML output jax if they desire.
This file includes all the important MathJax components for TeX input and
output, including the `tex2jax` preprocessor and TeX input jax, the
AMSmath, AMSsymbols, noErrors, and noUndefined TeX extensions, the
HTML-with-CSS output processor definition, and the MathMenu and MathZoom
extensions. It is equivalent to the following configuration:
.. code-block:: javascript
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js","MathMenu.js","MathZoom.js"],
TeX: {
extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
}
});
In addition, it loads the mml Element Jax and the TeX input jax main code
(not just the definition file), as well as the `toMathML` extension, which
is used by the Show Source option in the MathJax contextual menu. The ``-full``
version also loads the HTML-CSS output jax main code, plus the HTML-CSS
`mtable` extension, which is normally loaded on demand.
See the :ref:`tex2jax configuration <configure-tex2jax>` section for
other configuration options for the ``tex2jax`` preprocessor, and the
:ref:`TeX input jax configuration <configure-TeX>` section for options
that control the TeX input processor.
See :ref:`MathJax Output Formats <output-formats>` for more
information on the HTML-CSS output processor.
The ``MML_HTMLorMML`` configuration file
================================================
This configuration file is for sites that only use MathML format for their
mathematics. It will use MathML output in browsers where that is
supported well, and HTML-CSS output otherwise. The user can still use the
MathJax contextual menu to select the other output format if they desire.
This file includes all the important MathJax components for MathML input
and output, including the `mml2jax` preprocessor and MathML input jax, the
NativeMML and HTML-CSS output processor definition files, and the MathMenu
and MathZoom extensions. It is equivalent to the following configuration:
.. code-block:: javascript
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: ["input/MathML","output/HTML-CSS","output/NativeMML"],
extensions: ["mml2jax.js","MathMenu.js","MathZoom.js"]
});
In addition, it loads the mml Element Jax and the MathML input jax main
code (not just the definition file), as well as the `toMathML` extension,
which is used by the Show Source option in the MathJax contextual menu.
The ``-full`` version also loads both the HTML-CSS and NativeMML output jax main
code files, plus the HTML-CSS `mtable` extension, which is normally loaded
on demand.
See the :ref:`mml2jax configuration <configure-mml2jax>` section for
other configuration options for the ``mml2jax`` preprocessor, and the
:ref:`MathML input jax configuration <configure-MathML>` section for
options that control the MathML input processor.
See :ref:`MathJax Output Formats <output-formats>` for more
information on the NativeMML and HTML-CSS output processors. See the
:ref:`MMLorHTML configuration <configure-MMLorHTML>` section for
details on the options that control the ``MMLorHTML`` configuration.
The ``AM_HTMLorMML`` configuration file
================================================
This configuration file is for sites that only use AsciiMath format for their
mathematics. It will use MathML output in browsers where that is
supported well, and HTML-CSS output otherwise. The user can still use the
MathJax contextual menu to select the other output format if they desire.
This file includes all the important MathJax components for AsciiMath
input and output, including the `asciimath2jax` preprocessor and
AsciiMath input jax, the NativeMML and HTML-CSS output processor
definition files, and the MathMenu and MathZoom extensions. It is
equivalent to the following configuration:
.. code-block:: javascript
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: ["input/AsciiMath","output/HTML-CSS","output/NativeMML"],
extensions: ["asciimath2jax.js","MathMenu.js","MathZoom.js"]
});
In addition, it loads the mml Element Jax and the TeX input jax main code
(not just the definition file), as well as the `toMathML` extension, which
is used by the Show Source option in the MathJax contextual menu. The ``-full``
version also loads the HTML-CSS output jax main code, plus the HTML-CSS
`mtable` extension, which is normally loaded on demand.
See the :ref:`asciimath2jax configuration <configure-asciimath2jax>`
section for other configuration options for the ``asciimath2jax``
preprocessor, and the :ref:`AsciiMath input jax configuration
<configure-AsciiMath>` section for options that control the AsciiMath
input processor. See :ref:`MathJax Output Formats <output-formats>`
for more information on the HTML-CSS and NativeMML output processors.
See the :ref:`MMLorHTML configuration <configure-MMLorHTML>` section
for details on the options that control the ``MMLorHTML``
configuration.
The ``TeX-AMS-MML_SVG`` configuration file
================================================
This configuration file is the same as `TeX-AMS-MML_HTMLorMML` except
that it uses the SVG output renderer rather than the NativeMML or
HTML-CSS ones. It loads all the main MathJax components, including
the TeX and MathML preprocessors and input processors, the AMSmath,
AMSsymbols, noErrors, and noUndefined TeX extensions, the SVG output
processor definitions, and the MathMenu and MathZoom extensions. It
is equivalent to the following configuration:
.. code-block:: javascript
MathJax.Hub.Config({
jax: ["input/TeX","input/MathML","output/SVG"],
extensions: ["tex2jax.js","mml2jax.js","MathMenu.js","MathZoom.js"],
TeX: {
extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
}
});
In addition, it loads the mml Element Jax, the TeX and MathML input
jax main code (not just the definition files), as well as the
`toMathML` extension, which is used by the Show Source option in the
MathJax contextual menu. The ``-full`` version also loads both the
SVG output jax main code, plus the SVG `mtable` extension, which
is normally loaded on demand.
See the :ref:`tex2jax configuration <configure-tex2jax>` section for
other configuration options for the ``tex2jax`` preprocessor, and the
:ref:`TeX input jax configuration <configure-TeX>` section for options
that control the TeX input processor.
See the :ref:`mml2jax configuration <configure-mml2jax>` section for
other configuration options for the ``mml2jax`` preprocessor, and the
:ref:`MathML input jax configuration <configure-MathML>` section for
options that control the MathML input processor.
See :ref:`MathJax Output Formats <output-formats>` for more
information on the SVG output processor.
The ``Accessible`` configuration file
================================================
This configuration file is essentially the same as
``TeX-AMS-MML_HTMLorMML`` except that it includes options that are
designed for assistive technology, particularly for those with visual
challenged. *This file is deprecated* since the controls that make
MathJax work with screen readers are now available in the MathJax
contextual menu, and so there is no need to set them in the
configuration file any longer. So you can use any of the other
pre-defined configurations and readers with special needs should be
able to change the MathJax settings themselves to be appropriate for
their software.
The Accessible configuration is equivalent to the following:
.. code-block:: javascript
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML"],
extensions: ["tex2jax.js","mml2jax.js","MathMenu.js","MathZoom.js"],
TeX: {
extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
},
menuSettings: {
zoom: "Double-Click",
mpContext: true,
mpMouse: true
},
errorSettings: { message: ["[Math Error]"] }
});
This turns off the MathJax contextual menu for IE when MathPlayer is
active, and passes mouse events on to MathPlayer to allow screen
readers full access to MathPlayer. It also sets the zoom trigger
to double-click, so that readers can see a larger version of the
mathematics but double-clicking on any equation.
In addition, it loads the mml Element Jax, the TeX and MathML input jax
main code (not just the definition files), as well as the `toMathML`
extension, which is used by the Show Source option in the MathJax
contextual menu. The ``-full`` version also loads both the HTML-CSS and
NativeMML output jax main code, plus the HTML-CSS `mtable` extension, which
is normally loaded on demand.

479
docs/html/_sources/configuration.txt
View File

@ -1,479 +0,0 @@
.. _loading:
*******************************
Loading and Configuring MathJax
*******************************
You load MathJax into a web page by including its main JavaScript file
into the page. That is done via a ``<script>`` tag that links to the
``MathJax.js`` file. To do that, place the following line in the ``<head>``
section of your document:
.. code-block:: html
<script type="text/javascript" src="path-to-MathJax/MathJax.js"></script>
where ``path-to-MathJax`` is replaced by the URL of the copy of MathJax
that you are loading. For example, if you are using the MathJax
distributed network service, the tag might be
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js">
</script>
If you have installed MathJax yourself, ``path-to-MathJax`` will be the
location of MathJax on your server, or (if you are using MathJax locally
rather than through a server) the location of that directory on your hard
disk. For example, if the MathJax directory is at the top level of your
web server's directory hierarchy, you might use
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js"></script>
to load MathJax.
If you install MathJax on a server in a domain that is different from the
one containing the page that will load MathJax, then there are issues
involved in doing so that you need to take into consideration. See the
:ref:`Notes About Shared Servers <cross-domain-linking>` for more details.
When you load MathJax, it is common to request a specific
configuration file as discussed in the section on :ref:`Using a
Configuration File <config-files>` below, and in more detail in the
:ref:`Common Configurations <common-configurations>` section. A
typical invocation of MathJax would be
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
which loads MathJax with a configuration file that includes everything
you need in order to enter mathematics in either TeX, LaTeX, or MathML
notation, and produces output using MathML if the browser supports
that well enough, or HTML-with-CSS otherwise. If you **don't** load
an explicit configuration file, you will need to include an in-line
configuration block in order to tell MathJax how to read and display
the mathematics on your pages. See the section below on :ref:`Using
In-line Configuration Options <inline-config>` for details.
It is best to load MathJax in the document's ``<head>`` block, but it
is also possible to load MathJax into the ``<body>`` section, if
needed. If you do this, load it as early as possible, as
MathJax will begin to load its components as soon as it is included in
the page, and that will help speed up the processing of the
mathematics on your page. MathJax does expect there to be a
``<head>`` section to the document, however, so be sure there is one
if you are loading MathJax in the ``<body>``.
It is also possible to load MathJax dynamically after the page has
been prepared, for example, via a `GreaseMonkey
<http://www.greasespot.net/>`_ script, or using a specially prepared
`bookmarklet <http://en.wikipedia.org/wiki/Bookmarklet>`_. This is an
advanced topic, however; see :ref:`Loading MathJax Dynamically
<ajax-mathjax>` for more details.
.. _loading-CDN:
Loading MathJax from the CDN
============================
MathJax is available as a web service from ``cdn.mathjax.org``, so you
can obtain MathJax from there without needing to install it on your own
server. The CDN is part of a distributed "cloud" network, so it is
handled by servers around the world. That means that you should get access
to a server geographically near you, for a fast, reliable connection.
The CDN hosts the most current version of MathJax, as well as older
versions, so you can either link to a version that stays up-to-date as
MathJax is improved, or you can stay with one of the release versions so
that your pages always use the same version of MathJax.
The URL that you use to obtain MathJax determines the version that you
get. The CDN has the following directory structure:
.. code-block:: sh
mathjax/ # project-name
1.0-latest/
1.1-latest/ # the 1.1 release with any ciritical patches
2.0-beta/ # temporary
2.0-latest/ # the 2.0 release with any ciritical patches
...
latest/ # the most current version (2.0-latest in this case)
Each directory corresponds to an official MathJax release; however,
hotfixes (urgent bug fixes) will be applied in each release branch as
necessary, even if new releases are not prepared. In other words,
``1.1-latest`` will initially point to v1.1, but over time may be updated
with patches that would correspond to releases that might be numbers 1.1a,
1.1b, etc., even if such releases are not actually packaged for
separate distribution (they likely won't be).
We may occasionally introduce directories for betas, as indicated above,
but they will be temporary, and will be removed after the official
release.
To load from a particular release, use the directory for that release.
For example,
.. code-block:: html
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/1.1-latest/MathJax.js"></script>
will load the stable v1.1 version, even after we release v2.0 or other later
versions, while
.. code-block:: html
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js"></script>
will always be the most current stable release, so it will go from v1.1 to
v2.0 automatically when that is released. Note that all the versions
available on the CDN are stable versions; the development version is not
hosted on the CDN. (If you wish to use the development version of
MathJax, you will need to install your own copy; see :ref:`Installing
and Testing MathJax <installation>` for information on how to do that.)
The use of ``cdn.mathjax.org`` is governed by its `terms of service
<http://www.mathjax.org/download/mathjax-cdn-terms-of-service/>`_, so be
sure to read that before linking to the MathJax CDN server.
If you wish to use the MathJax CDN but use your own configuration file
rather than one of the pre-defined ones, see the information at the
end of the :ref:`Using a Local Configuration File
<local-config-files>` section below.
Configuring MathJax
===================
There are two ways to configure MathJax: via a configuration file, or by
including configuration commands within the web page itself. These can be
used independently, or in combination. For example, you can load a main
pre-defined configuration file, but include in-line commands to
adjust the configuration to your needs.
Note that you must use at least one of these two forms of configuration.
Unlike MathJax v1.0, version 1.1 and higher does not load a default
configuration file. If you have been using version 1.0's
``config/MathJax.js`` for your configuration, you will need to load that
configuration file explicitly via a ``config`` parameter, as described
below.
.. _config-files:
Using a configuration file
==========================
The first way to configure MathJax is to use a configuration file.
MathJax comes with a number of pre-defined configuration files, which are
stored in the ``MathJax/config`` directory. Among these are the following
.. describe:: default.js
A file that contains nearly all the configuration options with comments
describing them, which you can edit to suit your needs.
.. describe:: TeX-AMS-MML_HTMLorMML.js
Allows math to be specified in :term:`TeX`, :term:`LaTeX`, or
:term:`MathML` notation, with the `AMSmath` and `AMSsymbols`
packages included, producing output using MathML if the browser
supports it sufficiently, and HTML-with-CSS otherwise.
.. describe:: TeX-AMS_HTML.js
Allows math to be specified in :term:`TeX` or :term:`LaTeX` notation, with the
`AMSmath` and `AMSsymbols` packages included, and produces output
using the HTML-CSS output processor.
.. describe:: MML_HTMLorMML.js
Allows math to be specified using :term:`MathML` notation, and produces MathML
output if the browser supports it sufficiently, or HTML-CSS output otherwise.
.. describe:: AM_HTMLorMML.js
Allows math to be specified using :term:`AsciiMath` notation,
producing output in MathML if the browser supports it
sufficiently, or as HTML-with-CSS otherwise.
.. describe:: TeX-AMS-MML_SVG.js
Allows math to be specified in :term:`TeX`, :term:`LaTeX`, or
:term:`MathML` notation, with the `AMSmath` and `AMSsymbols`
packages included, producing output using SVG.
.. describe:: TeX-MML-AM_HTMLorMML.js
Allows math to be specified in :term:`TeX`, :term:`LaTeX`,
:term:`MathML`, or :term:`AsciiMath` notation, with the `AMSmath`
and `AMSsymbols` packages included, producing output using MathML
if the browser supports it sufficiently, and HTML-with-CSS
otherwise.
The first of these is a file that you can edit to suit your needs. It
contains nearly all the configuration options that MathJax allows, and has
comments explaining them. The others are what are called `combined
configuration files`, which not only configure MathJax, but also pre-load the
various files that the configuration requires. (The contents of these
files are explained in more detail in the `Common Configurations
<common-configurations>`_ section.)
Usually, MathJax loads its components only when they are needed, but each
component will require a separate file to be loaded, and that can cause
delays before the mathematics is displayed. The combined configuration
files load the majority of the needed files all as one large file, reducing
the number of network requests that are needed. That means you will
probably be getting the components that MathJax needs faster than you would
without the combined file, but you may be loading components that are never
actually used; that is the trade off.
Each of the combined configuration files comes in two flavors: the ones
listed above, which only configure the output processors but don't include
the main code, and a "full" version, that also includes the complete
output processors. For example, with ``TeX-AMS_HTML.js`` and
``TeX-AMS_HTML-full.js``, the latter includes the complete HTML-CSS output
processor. The "full" configuration files are substantially larger (on
the order of 70KB more), so you need to decide whether it is worth loading the
full configuration for your pages.
If most of your pages include mathematics, then it is to your advantage to
load the full version, but if you are including MathJax in a theme file for
a blog or wiki that only includes mathematics occasionally, then perhaps it
is better to use the standard configuration instead, in which case the
output processors are only loaded when they are actually needed, saving the
loading of 70KB for pages that don't. Of course, if your server is
configured to compress the files it sends, the difference between the two
is considerably reduced. Furthermore, most browsers will cache the
javascript they receive, so the download cost should only occur on the
first page a user views, so it may be best to use the "full" version after
all. Note, however, that mobile devices sometimes have limits on the size
of files that they cache, so they may be forced to download the
configuration on every page. You need to keep these issues in mind as you
decide on which configuration to use.
To load a configuration file, use ``config=filename`` (where ``filename``
is one of the names above without the ``.js``) as a parameter to the URL of
the ``MathJax.js`` file. For example
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
loads the ``config/TeX-AMS-MML_HTMLorMML.js`` configuration file from the
MathJax distributed network service.
You can include more than one configuration file by separating them with
commas. For example, if you have a locally defined configuration file
called ``MathJax/config/local/local.js`` that modifies the settings for the
``TeX-AMS_HML`` configuration, defines some new TeX macros, and so on, you
can use
.. code-block:: html
<script type="text/javascript"
src="path-to-MathJax/MathJax.js?config=TeX-AMS_HTML,local/local">
</script>
to first load the main configuration, then the local modifications.
.. _local-config-files:
Using a local configuration file with the CDN
=============================================
You can load MathJax from the MathJax CDN server but still use a
configuration from your own local server. For example, suppose you
have a configuration file called ``local.js`` on your own server, in a
directory called ``MathJax/config/local``. Then you can load MathJax
from the CDN and still use your configuration file as follows:
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML,http://myserver.com/MathJax/config/local/local.js">
</script>
Because the ``local.js`` file is not on the CDN server, you must give
the complete URL to the local configuration file. Note that you also
have to edit the :meth:`loadComplete()` call that is at the bottom of
the configuration file to change it from
``[MathJax]/config/local/local.js`` to the complete URL as you give it
in the ``config`` parameter. In the example above, it would be
.. code-block:: javascript
MathJax.Ajax.loadComplete("http://myserver.com/MathJax/config/local/local.js");
That is because the ``[MathJax]`` in the original URL refers to the
root directory where ``MathJax.js`` was loaded, which is on the CDN,
not your local server, and so you need to tell MathJax the actual
location of your configuration file.
.. _inline-config:
Using in-line configuration options
===================================
The second way to configure MathJax is through `in-line configuration`,
which puts the configuration options within the web page itself. The use
of in-line configuration with MathJax requires two separate ``<script>``
tags: one for specifying the configuration settings and one for loading of
MathJax. Because MathJax starts its configuration process as soon as it is
loaded, the configuration script must come **before** the script tag that
loads ``MathJax.js`` itself. You do this by including a ``<script>`` with
``type="text/x-mathjax-config"`` whose content will be run when
MathJax performs its configuration. Generally, this script will
include a :meth:`MathJax.Hub.Config()` call to perform MathJax
configuration, but it can also include other MathJax commands, such as
registering signal actions, or any JavaScript commands that you want.
You can have as many such script tags as you need, and MathJax will
process them in the order in which they appear in the document.
For instance,
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
extensions: ["tex2jax.js"],
jax: ["input/TeX", "output/HTML-CSS"],
tex2jax: {
inlineMath: [ ['$','$'], ["\\(","\\)"] ],
displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
processEscapes: true
},
"HTML-CSS": { availableFonts: ["TeX"] }
});
</script>
<script type="text/javascript" src="path-to-MathJax/MathJax.js">
This example includes the `tex2jax` preprocessor and configures it to use
both the standard :term:`TeX` and :term:`LaTeX` math delimiters. It uses
the `TeX` input processor and the `HTML-CSS` output processor, and forces the
HTML-CSS processor to use the TeX fonts rather than other locally installed
fonts (e.g., :term:`STIX` fonts). See the :ref:`configuration options
<configuration>` section (or the comments in the ``config/default.js``
file) for more information about the configuration options that you can
include in the :meth:`MathJax.Hub.Config()` call. This
configuration does **not** load any pre-defined configuration file.
Note that you can combine in-line configuration with file-based
configuration; simply include ``text/x-mathjax-config`` scripts as above,
but also include ``config=filename`` when you load the ``MathJax.js``
file. For example, the `tex2jax` preprocessor does **not** enable the TeX
single-dollar in-line math delimiters by default. You can load one of the
pre-defined configuration files that includes the TeX preprocessor, and use
an in-line configuration block to enable the single-dollar signs, as
in this example:
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {
inlineMath: [ ['$','$'], ["\\(","\\)"] ],
processEscapes: true
}
});
</script>
<script type="text/javascript" src="path-to-MathJax/MathJax.js?config=TeX-AMS_HTML">
</script>
.. _delayStartupUntil:
Configuring MathJax after it is loaded
======================================
Because MathJax begins its configuration process immediately after it is
loaded (so that it can start loading files as quickly as it can), the
configuration blocks for MathJax must come before ``MathJax.js`` is loaded,
so they will be available to MathJax when it starts up. There are
situations, however, when you might want to put off configuring MathJax
until later in the page.
One such situation is when you have a site that loads MathJax as part of a
theme or template, but want to be able to modify the configuration on
specific pages of the site. To accomplish this, you need to ask MathJax
to delay its startup configuration until some later time. MathJax uses
the ``delayStartupUntil`` parameter to control the timing of the startup
sequence. By default, it is set to ``none``, meaning there is no delay
and MathJax starts configuration right away.
You can set ``delayStartupUntil=onload`` in order to prevent MathJax from
continuing its startup process until the page's onLoad handler fires. This
allows MathJax to find the ``text/x-mathjax-config`` blocks that occur
anywhere on the page, not just the ones that appear above the ``<script>``
that loads ``MathJax.js``. It also means that MathJax will not begin
loading any of the files that it needs until then as well, which may delay
the displaying of your mathematics, since the onLoad handler doesn't
execute until all the images and other media are available. (If you have
used a combined configuration file, however, it already includes all the
main files that MathJax needs, so there is not much loss in delaying the
startup.)
You can set ``delayStartupUntil=configured`` in order to delay the
startup configuration until the :meth:`MathJax.Hub.Configured()`
method is called. This allows you to delay startup until later on the
page, but then restart the MathJax configuration process as soon as
possible rather than waiting for the entire page to load. For
example, you could use
.. code-block:: html
<script type="text/javascript"
src="path-to-MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML&delayStartupUntil=configured">
</script>
in your theme's header file, and
.. code-block:: html
<script type="text/javascript">
MathJax.Hub.Configured()
</script>
in its footer, so that MathJax will delay setting up until the footer
is reached, but will not have to wait until images and other files are
loaded. In this way, if you have ``text/x-mathjax-config`` script
tags within the main body of the document, MathJax will read and
process those before continuing its startup. In this way you can use
a default configuration that can be modified on a page-by-page basis.
Note that :meth:`MathJax.Hub.Configured()` is not called by MathJax;
you must make that call somewhere within the page yourself after the
configuration blocks are set up. If you do not execute this function,
MathJax will not process any of the math on the page.
Details of the MathJax configuration process
============================================
Since there are a number of different ways to configure MathJax, it is
important to know how they interact. The configuration actions are the
following:
1. Process any configuration file explicitly specified as a script parameter.
2. Process the in-line script body (deprecated), if present.
3. If delayed startup is requested, wait for the indicated signal.
4. Process ``text/x-mathjax-config`` config blocks.
5. Process any config files queued in the configuration's `config` array
by earlier config code.
Note that ``text/x-mathjax-config`` script blocks must either precede the
``MathJax.js`` script element, or startup must be delayed. Otherwise, blocks
that follow the ``MathJax.js`` script element may or may not be available
when MathJax runs, and browser-dependent erratic behavior will result.

154
docs/html/_sources/dynamic.txt
View File

@ -1,154 +0,0 @@
.. _ajax-mathjax:
***************************
Loading MathJax Dynamically
***************************
MathJax is designed to be included via a ``<script>`` tag in the
``<head>`` section of your HTML document, and it does rely on being
part of the original document in that it uses an ``onload`` or
``DOMContentLoaded`` event handler to synchronize its actions with the
loading of the page. If you wish to insert MathJax into a document
after it has been loaded, that will normally occur *after* the page's
``onload`` handler has fired, and prior to version 2.0, MathJax had to
be told not to wait for the page ``onload`` event by calling
:meth:`MathJax.Hub.Startup.onload()` by hand. That is no longer
necessary, as MathJax v2.0 detects whether the page is already
available and when it is, it processes it immediately rather than
waiting for an event that has already happened.
Here is an example of how to load and configure MathJax dynamically:
.. code-block:: javascript
(function () {
var script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
document.getElementsByTagName("head")[0].appendChild(script);
})();
If you need to provide in-line configuration, you can do that using a
MathJax's configuration script:
.. code-block:: javascript
(function () {
var head = document.getElementsByTagName("head")[0], script;
script = document.createElement("script");
script.type = "text/x-mathjax-config";
script[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({\n" +
" tex2jax: { inlineMath: [['$','$'], ['\\\\(','\\\\)']] }\n" +
"});"
head.appendChild(script);
script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
head.appendChild(script);
})();
You can adjust the configuration to your needs, but be careful to get
the commas right, as Internet Explorer 6 and 7 will not tolerate an
extra comma before a closing brace. The ``window.opera`` test is
because some versions of Opera don't handle setting ``script.text``
properly, while some versions of Internet Explorer don't handle
setting ``script.innerHTML``.
Note that the **only** reliable way to configure MathJax is to use an
in-line configuration block of the type discussed above. You should
**not** call :meth:`MathJax.Hub.Config()` directly in your code, as it will
not run at the correct time --- it will either run too soon, in which case
``MathJax`` may not be defined and the function will throw an error, or it
will run too late, after MathJax has already finished its configuration
process, so your changes will not have the desired effect.
MathJax and GreaseMonkey
========================
You can use techniques like the ones discussed above to good effect in
GreaseMonkey scripts. There are GreaseMonkey work-alikes for all the
major browsers:
- Firefox: `GreaseMonkey <http://addons.mozilla.org/firefox/addon/748>`_
- Safari: `GreaseKit <http://8-p.info/greasekit/>`_ (also requires `SIMBL <http://www.culater.net/software/SIMBL/SIMBL.php>`_)
- Opera: Built-in (`instructions <http://www.ghacks.net/2008/08/10/greasemonkey-in-opera/>`_)
- Internet Explorer: `IEPro7 <http://www.ie7pro.com/>`_
- Chrome: Built-in for recent releases
Note, however, that most browsers don't allow you to insert a script
that loads a ``file://`` URL into a page that comes from the web (for
security reasons). That means that you can't have your GreaseMonkey
script load a local copy of MathJax, so you have to refer to a
server-based copy. The MathJax CDN works nicely for this.
----
Here is a script that runs MathJax in any document that contains
MathML (whether it includes MathJax or not). That allows
browsers that don't have native MathML support to view any web pages
with MathML, even if they say it only works in Firefox and
IE+MathPlayer.
.. code-block:: javascript
// ==UserScript==
// @name MathJax MathML
// @namespace http://www.mathjax.org/
// @description Insert MathJax into pages containing MathML
// @include *
// ==/UserScript==
if ((window.unsafeWindow == null ? window : unsafeWindow).MathJax == null) {
if ((document.getElementsByTagName("math").length > 0) ||
(document.getElementsByTagNameNS == null ? false :
(document.getElementsByTagNameNS("http://www.w3.org/1998/Math/MathML","math").length > 0))) {
var script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML-full";
document.getElementsByTagName("head")[0].appendChild(script);
}
}
**Source**: `mathjax_mathml.user.js <_static/mathjax_mathml.user.js>`_
----
Here is a script that runs MathJax in Wikipedia pages after first
converting the math images to their original TeX code.
.. code-block:: javascript
// ==UserScript==
// @name MathJax in Wikipedia
// @namespace http://www.mathjax.org/
// @description Insert MathJax into Wikipedia pages
// @include http://en.wikipedia.org/wiki/*
// ==/UserScript==
if ((window.unsafeWindow == null ? window : unsafeWindow).MathJax == null) {
//
// Replace the images with MathJax scripts of type math/tex
//
var images = document.getElementsByTagName('img'), count = 0;
for (var i = images.length - 1; i >= 0; i--) {
var img = images[i];
if (img.className === "tex") {
var script = document.createElement("script"); script.type = "math/tex";
if (window.opera) {script.innerHTML = img.alt} else {script.text = img.alt}
img.parentNode.replaceChild(script,img); count++;
}
}
if (count) {
//
// Load MathJax and have it process the page
//
var script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML-full";
document.getElementsByTagName("head")[0].appendChild(script);
}
}
**Source**: `mathjax_wikipedia.user.js <_static/mathjax_wikipedia.user.js>`_

109
docs/html/_sources/glossary.txt
View File

@ -1,109 +0,0 @@
.. _glossary:
********
Glossary
********
.. if you add new entries, keep the alphabetical sorting!
.. glossary::
AsciiMath
A notation for mathematics that uses characters commonly
available on all computer keyboards to represent the math in
an algebra-like syntax that should be intuitive and easily
read.
.. seealso::
`AsciiMath home page <http://www1.chapman.edu/~jipsen/mathml/asciimath.html>`_
Callback
A JavaScript function that is used to perform actions that
must wait for other actions to complete before they are
performed.
Callback Queue
MathJax uses `Queues` to synchronize its activity so that
actions that operate asynchronously (like loading files) will
be performed in the right order. :term:`Callback` functions
are pushed onto the queue, and are performed in order, with
MathJax handling the synchronization if operations need to
wait for other actions to finish.
Callback Signal
A JavaScript object that acts as a mailbox for MathJax events.
Like an event handler, but it also keeps a history of
messages. Your code can register an "interest" in a signal,
or can register a :term:`callback` to be called when a
particular message is sent along the signal channel.
HTML-CSS
MathJax output form that relys only on HTML and CSS 2.1,
allowing MathJax to remain compatible across all browsers.
jax
MathJax's input and output processors are called "jax", as is
its internal format manager. The code for the jax are in the
``MathJax/jax`` directory.
LaTeX
LaTeX is a variant of :term:`TeX` that is now the dominant TeX style.
.. seealso::
`LaTeX Wikipedia entry <http://en.wikipedia.org/wiki/LaTeX>`_
Markdown
A text format commonly used in blogs and wikis for creating
web pages without the need for complicated markup notation.
It is intended to be an easy-to-read and easy-to-write format
that still gives you the ability to specify a rich text result
(including things like bold, italics, bullet lists, and so
on).
.. seealso::
`Markdown home page <http://daringfireball.net/projects/markdown/>`_
MathML
An XML specification created to describe mathematical
notations and capture both its structure and content. MathML
is much more verbose than :term:`TeX`, but is much more
machine-readable.
.. seealso::
`MathML Wikipedia entry <http://en.wikipedia.org/wiki/MathML>`_
STIX
The Scientific and Technical Information Exchange font
package. A comprehensive set of scientific glyphs.
.. seealso::
`STIX project <http://stixfonts.org/>`_
SVG
Acronym for `Scalable Vector Graphics`. SVG is a graphics
format that allows images to be described as a collection of
graphics objects (like lines, rectangles, etc) rather than as
a bitmap of colored pixels. MathJax can use this format to
display mathematics as an alterantive to its HTML-CSS or
NativeMML output.
.. seealso::
`SVG Wilipedia entry <http://en.wikipedia.org/wiki/Scalable_Vector_Graphics>`_
TeX
A document markup language with robust math markup commands
developed by Donald Knuth in the late 1970's, but still in
extensive use today. It became the industry standard for
typesetting of mathematics, and is one of the most common
formats for mathematical journals, articles, and books.
.. seealso::
`TeX Wikipedia entry <http://en.wikipedia.org/wiki/TeX>`_

90
docs/html/_sources/index.txt
View File

@ -1,90 +0,0 @@
#####################
MathJax Documentation
#####################
MathJax is an open-source JavaScript display engine for LaTeX,
MathML, and AsciiMath notaion that works in all modern browsers.
Basic Usage
===========
.. toctree::
:maxdepth: 1
What is MathJax? <mathjax>
Getting Started with MathJax <start>
Installing and Testing MathJax <installation>
Loading and Configuring MathJax <configuration>
Common MathJax Configurations <config-files>
MathJax Configuration Options <options/index>
Using MathJax in Web Platforms <platforms/index>
.. toctree::
:maxdepth: 1
MathJax TeX and LaTeX Support <tex>
MathJax MathML Support <mathml>
MathJax AsciiMath Support <asciimath>
MathJax Output Formats <output>
.. toctree::
:maxdepth: 1
The MathJax Community <community>
.. _upgrading-MathJax:
Upgrading MathJax
=================
.. toctree::
:maxdepth: 1
What's New in MathJax v2.0 <whats-new-2.0>
What's New in MathJax v1.1 <whats-new-1.1>
Migrating from MathJax v1.0 to v1.1 <upgrade>
Converting to MathJax from jsMath <jsMath>
.. _advanced-topics:
Advanced Topics
===============
.. toctree::
:maxdepth: 1
The MathJax Processing Model <model>
The MathJax Startup Sequence <startup>
Synchronizing Your Code with MathJax <synchronize>
Loading MathJax Dynamically <dynamic>
Modifying Math on the Page <typeset>
.. toctree::
:maxdepth: 1
Details of the MathJax API<api/index>
Reference Pages
===============
.. toctree::
:maxdepth: 1
HTML snippets <HTML-snippets>
CSS style objects <CSS-styles>
Glossary <glossary>
* :ref:`Search <search>`
* `User Help Pages <http://www.mathjax.org/help/user>`_:
+ `MathJax Font Help <http://www.mathjax.org/help/fonts>`_
+ `MathJax Contextual Menu <http://www.mathjax.org/help/menu>`_
+ `MathJax Zoom Feature <http://www.mathjax.org/help/zoom>`_
--------
This version of the documentation was built |today|.

339
docs/html/_sources/installation.txt
View File

@ -1,339 +0,0 @@
.. _installation:
******************************
Installing and Testing MathJax
******************************
The easiest way to use MathJax is to link directly to the MathJax
distributed network service (see :ref:`Using the MathJax CDN
<mathjax-CDN>`). In that case, there is no need to install MathJax
yourself, and you can begin using MathJax right away; skip this document on
installation and go directly to :ref:`Configuring MathJax <loading>`.
MathJax can be loaded from a public web server or privately from your
hard drive or other local media. To use MathJax in either way, you
will need to obtain a copy of MathJax. There are three ways to do
this: via ``git``, ``svn``, or via a pre-packaged archive. We
recommend ``git`` or ``svn``, as it is easier to keep your
installation up to date with these tools.
.. _getting-mathjax-git:
Obtaining MathJax via Git
=========================
The easiest way to get MathJax and keep it up to date is to use the `Git
<http://git-scm.com/>`_ version control system to access our `GitHub repository
<http://github.com/mathjax/MathJax>`_. Use the command
.. code-block:: sh
git clone git://github.com/mathjax/MathJax.git MathJax
to obtain and set up a copy of MathJax. (Note that there is no longer
a ``fonts.zip`` file, as there was in v1.0, and that the ``fonts``
directory is now part of the repository itself.)
Whenever you want to update MathJax, you can now use
.. code-block:: sh
cd MathJax
git remote show origin
to check if there are updates to MathJax (this will print several
lines of data, but the last line should tell you if your copy is up to
date or out of date). If MathJax needs updating, use
.. code-block:: sh
cd MathJax
git pull origin
to update your copy of MathJax to the current release version. If you
keep MathJax updated in this way, you will be sure that you have the
latest bug fixes and new features as they become available.
This gets you the current development copy of MathJax, which is the version
that contains all the latest changes to MathJax. Although we try to make
sure this version is a stable and usable version of MathJax, it is under
active development, and at times it may be less stable than the "release"
version. If you prefer to use the most stable version (that may not
include all the latest patches and features), you will want to get one
of the tagged releases. Use
.. code-block:: sh
cd MathJax
git tag -l
to see all tagged versions, and use
.. code-block:: sh
cd MathJax
git checkout <tag_name>
to checkout the indicated version of MathJax, where ``<tag_name>`` is
the name of the tagged version you want to use. When you want to
upgrade to a new release, you will need to repeat this for the latest
release tag.
Each of the main releases also has a branch in which critical updates
are applied (we try hard not to patch the stable releases, but sometimes
there is a crucial change that needs to be made). If you want to use the
patched version of a release, then check out the branch rather than the
tag. Use
.. code-block:: sh
cd MathJax
git branch
to get a list of the available branches. There are separate branches
for the main releases, but with ``-latest`` appended. These contain
all the patches for that particular release. You can check out one of
the branches just as you would a tagged copy. For example, the branch
for the ``v2.0`` tagged release is ``v2.0-latest``. To get this
release, use
.. code-block:: sh
cd MathJax
git checkout v2.0-latest
and to update it when changes occur, use
.. code-block:: sh
cd MathJax
git pull origin v2.0-latest
.. _getting-mathjax-svn:
Obtaining MathJax via SVN
=========================
If you are more comfortable with the `subversion
<http://subversion.apache.org/>`_ source control system, you may want
to use GitHub's ``svn`` service to obtain MathJax. If you want to get the
latest revision using ``svn``, use the command
.. code-block:: sh
svn checkout http://github.com/mathjax/MathJax/trunk MathJax
to obtain and set up a copy of MathJax. (Note that there is no longer
a ``fonts.zip`` file as of v1.1, and that the ``fonts`` directory is
now part of the repository itself.)
Whenever you want to update MathJax, you can now use
.. code-block:: sh
cd MathJax
svn status -u
to check if there are updates to MathJax. If MathJax needs updating,
use
.. code-block:: sh
cd MathJax
svn update
to update your copy of MathJax to the current release version. If you
keep MathJax updated in this way, you will be sure that you have the
latest bug fixes and new features as they become available.
This gets you the current development copy of MathJax, which is the version
that contains all the latest changes to MathJax. Although we try to make
sure this version is a stable and usable version of MathJax, it is under
active development, and at times it may be less stable than the "release"
version. If you prefer to use one of the tagged releases instead,
then use
.. code-block:: sh
svn checkout http://github.com/mathjax/MathJax/branch/[name] MathJax
where ``[name]`` is replaced by the name of the branch you want to
check out; e.g., ``2.0-latest``. The branch names can be found on the
`GitHub MathJax page <http://github.com/mathjax/MathJax/>`_ under the
`branches <https://github.com/mathjax/MathJax/branches>`_ tab.
.. _getting-mathjax-zip:
Obtaining MathJax via an archive
================================
Release versions of MathJax are available in archive files from the
`MathJax download page <http://www.mathjax.org/download/>`_ or the
`MathJax GitHub page <http://github.com/mathjax/mathjax/>`_ (via the
"zip" button, or the "downloads" tab), where you can download the archive
that you need.
You should download the v2.0 archive (which will get you a file with a
name like ``mathjax-MathJax-v2.0-X-XXXXXXXX.zip``, where the X's are
some sequence of random-looking letters and numbers), then simply unzip
it. Once the MathJax directory is unpacked, you should move it to the
desired location on your server (or your hard disk, if you are using
it locally rather then through a web server). One natural location is
to put it at the top level of your web server's hierarchy. That would
let you refer to the main MathJax file as ``/MathJax/MathJax.js`` from
within any page on your server.
From the `MathJax GitHub download link
<http://github.com/mathjax/mathjax/downloads>`_, you can also select
the ``Download .tar.gz`` or ``Download .zip`` buttons to get a copy of
the current development version of MathJax that contains all the
latest changes and bug-fixes.
If a packaged release receives any important updates, then those
updates will be part of the `branch` for that version. The link to
the ``.zip`` file in the download list will be the original release
version, not the patched version. To obtain the patched version, use
the `Branches` drop down menu (at the far left of the menus within the
page) to select the release branch that you want (for example
``v2.0-latest``), and then use the "zip" button just above it to get
the latest patched version of that release.
Testing your installation
=========================
Use the HTML files in the ``test`` directory to see if your
installation is working properly::
test/
index.html # Tests default configuration
index-images.html # Tests image-font fallback display
sample.html # Sample page with lots of pretty equations
examples.html # Page with links to all sample pages
Open these files in your browser to see that they appear to be working
properly. If you have installed MathJax on a server, use the web
address for those files rather than opening them locally. When you
view the ``index.html`` file, you should see (after a few moments) a
message that MathJax appears to be working. If not, you should check
that the files have been transferred to the server completely, and that
the permissions allow the server to access the files and folders that
are part of the MathJax directory (be sure to verify the MathJax
folder's permissions as well). Checking the server logs may help
locate problems with the installation.
.. _cross-domain-linking:
Notes about shared installations
================================
Typically, you want to have MathJax installed on the same server as
your web pages that use MathJax. There are times, however, when that
may be impractical, or when you want to use a MathJax installation at
a different site. For example, a departmental server at
``www.math.yourcollege.edu`` might like to use a college-wide
installation at ``www.yourcollege.edu`` rather than installing a
separate copy on the departmental machine. MathJax can certainly
be loaded from another server, but there is one important caveat ---
Firefox's and IE9's same-origin security policy for cross-domain scripting.
Firefox's interpretation of the same-origin policy is more strict than most
other browsers, and it affects how fonts are loaded with the `@font-face`
CSS directive. MathJax uses this directive to load web-based math fonts
into a page when the user doesn't have them installed locally on their own
computer. Firefox's security policy, however, only allows this when the
fonts come from the same server as the web page itself, so if you load
MathJax (and hence its web fonts) from a different server, Firefox won't be
able to access those web fonts. In this case, MathJax will pause while
waiting for the font to download (which will never happen); it will time
out after about 5 seconds and switch to image fonts as a fallback.
Similarly, IE9 has a similar same-origin policy in its `IE9 standards
mode`, so it exhibits this same behavior.
There is a solution to this, however, if you manage the server where
MathJax is installed, and if that server is running the `Apache web
server <http://www.apache.org/>`_. In the remote server's
``MathJax/fonts/`` folder, create a file called
``.htaccess`` that contains the following lines:
::
<FilesMatch "\.(ttf|otf|eot|woff)$">
<IfModule mod_headers.c>
Header set Access-Control-Allow-Origin "*"
</IfModule>
</FilesMatch>
and make sure the permissions allow the server to read this file. (The
file's name starts with a period, which causes it to be an "invisible" file
on unix-based operating systems. Some systems, particularly those with
graphical user interfaces, may not allow you to create such files, so you
might need to use the command-line interface to accomplish this.)
This file should make it possible for pages at other sites to load MathJax
from this server in such a way that Firefox and IE9 will be able to
download the web-based fonts. If you want to restrict the sites that can
access the web fonts, change the ``Access-Control-Allow-Origin`` line to
something like::
Header set Access-Control-Allow-Origin "http://www.math.yourcollege.edu"
so that only pages at ``www.math.yourcollege.edu`` will be able to
download the fonts from this site. See the open font library
discussion of `web-font linking
<http://openfontlibrary.org/wiki/Web_Font_linking_and_Cross-Origin_Resource_Sharing>`_
for more details.
.. _ff-local-fonts:
Firefox and local fonts
=======================
Firefox's same-origin security policy affects its ability to load
web-based fonts, as described above. This has implications not only
to cross-domain loading of MathJax, but also to using MathJax locally
from your hard disk. Firefox's interpretation of the same-origin
policy for local files is that the "same domain" for a page is the
directory where that page exists, or any of its subdirectories. So if
you use MathJax in a page with a ``file://`` URL, and if MathJax is
loaded from a directory other than the one containing the original
page, then MathJax will not be able to access the web-based fonts in
Firefox. In that case, MathJax will fall back on image fonts to
display the mathematics.
In order for Firefox to be able to load the fonts properly for a local
file, your MathJax installation must be in a subdirectory of the one
containing the page that uses MathJax. This is an unfortunate
restriction, but it is a limitiation imposed by Firefox's security
model that MathJax can not circumvent. Currently, this is not a
problem for other browsers.
One solution to this problem is to install the MathJax fonts locally, so
that Firefox will not have to use web-based fonts in the first place. To
do that, either install the `STIX fonts <http://stixfonts.org>`_, or copy
the fonts from ``MathJax/fonts/HTML-CSS/TeX/otf`` into your systems fonts
directory and restart your browser (see the `MathJax fonts help page
<http://www.mathjax.org/help/fonts>`_ for details).
IE9 and remote fonts
====================
IE9's same-origin policy affects its ability to load web-based fonts, as
described above. This has implications not ony to cross-domain loading of
MathJax, but also to the case where you view a local page (with a
``file://`` URL) that accesses MathJax from a remote site such as the MathJax
CDN service. In this case, IE9 does **not** honor the
``Access-Control-Allow-Origin`` setting of the remote server (as it would
if the web page came from an ``http://`` URL), and so it **never** allows the
font to be accessed.
One solution to this problem is to install the MathJax fonts locally so
that MathJax doesn't have to use web-based fonts in the first place. Your
best bet is to install the `STIX fonts`_ on your system (see the `MathJax
fonts help page`_ for details).

49
docs/html/_sources/jsMath.txt
View File

@ -1,49 +0,0 @@
.. _jsMath-support:
*********************************
Converting to MathJax from jsMath
*********************************
MathJax is the successor to the popular `jsMath
<http://www.math.union.edu/locate/jsMath/>`_ package for rendering
mathematics in web pages. Like jsMath, MathJax works by locating and
processing the mathematics within the webpage once it has been loaded
in the browser by a user viewing your web pages. If you are using
jsMath with its ``tex2math`` preprocessor, then switching to MathJax
should be easy, and is simply a matter of configuring MathJax
appropriately. See the section on :ref:`Loading and Configuring MathJax
<loading>` for details.
On the other hand, if you are using jsMath's ``<span
class="math">...</span>`` and ``<div class="math">...</div>`` tags to
mark the mathematics in your document, then you should use MathJax's
``jsMath2jax`` preprocessor when you switch to MathJax. To do this,
include ``"jsMath2jax.js"`` in the `extensions` array of your
configuration, with the `jax` array set to include ``"input/TeX"``. For
example,
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
extensions: ["jsMath2jax.js"]
});
</script>
<script
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML">
</script>
would load the ``jsMath2jax`` preprocessor, along with a configuration
file that processes TeX input and produces HTML-with-CSS output.
There are a few configuration options for ``jsMath2jax``, which you
can find in the ``config/default.js`` file, or in the :ref:`jsMath
configuration options <configure-jsMath2jax>` section.
If you are generating your jsMath documents programmatically, it would be
better to convert from generating the jsMath ``<span>`` and ``<div>`` tags
to producing the corresponding MathJax ``<script>`` tags. You would use
``<script type="math/tex">`` in place of ``<span class="math">`` and
``<script type="math/tex; mode=display">`` in place of ``<div
class="math">``. See the section on :ref:`How mathematics is stored in the
page <mathjax-script-tags>` for more details.

38
docs/html/_sources/mathjax.txt
View File

@ -1,38 +0,0 @@
****************
What is MathJax?
****************
MathJax is an open-source JavaScript display engine for LaTeX, MathML,
and AsciiMath notation that works in all modern browsers. It was
designed with the goal of consolidating the recent advances in web
technologies into a single, definitive, math-on-the-web platform
supporting the major browsers and operating systems, including those
on mobile devices. It requires no setup on the part of the user (no
plugins to download or software to install), so the page author can
write web documents that include mathematics and be confident that
users will be able to view it naturally and easily. One simply
includes MathJax and some mathematics in a web page, and MathJax does
the rest.
MathJax uses web-based fonts (in those browsers that support it) to
produce high-quality typesetting that scales and prints at full
resolution (unlike mathematics included as images). MathJax can be
used with screen readers, providing accessibility for the visually
impaired. With MathJax, mathematics is text-based rather than
image-based, and so it is available for search engines, meaning that
your equations can be searchable, just like the text of your pages.
MathJax allows page authors to write formulas using TeX and LaTeX
notation, `MathML <http://www.w3.org/TR/MathML3>`_, a World Wide Web
Consortium standard for representing mathematics in XML format, or
`AsciiMath <http://www1.chapman.edu/~jipsen/mathml/asciimath.html>`_
notation. MathJax will even convert TeX notation into MathML, so that
it can be rendered more quickly by those browsers that support MathML
natively, or so that you can copy and paste it into other programs.
MathJax is modular, so it loads components only when necessary, and
can be extended to include new capabilities as needed. MathJax is
highly configurable, allowing authors to customize it for the special
requirements of their web sites. Finally, MathJax has a rich
application programming interface (API) that can be used to make the
mathematics on your web pages interactive and dynamic.

101
docs/html/_sources/mathml.txt
View File

@ -1,101 +0,0 @@
.. _MathML-support:
**********************
MathJax MathML Support
**********************
The support for :term:`MathML` in MathJax consists of three parts: the
`mml2jax` preprocessor, the `MathML` input processor, and the `NativeMML`
output processor. The first of these looks for ``<math>`` tags within
your document and marks them for later processing by MathJax. The
second converts the MathML to the internal format used by MathJax, and
the third turns the internal format into MathML within the page so
that it can be displayed by the browser's native MathML support.
Because of MathJax's modular design, you do not need to use all three
of these components. For example, you could use the `tex2jax`
preprocessor and the TeX input processor, but the NativeMML output
processor, so that your mathematics is entered in TeX format, but
displayed as MathML. Or you could use the `mml2jax` preprocessor and
MathML input processor with the HTML-CSS output processor to make
MathML available in browsers that don't have native MathML support.
It is also possible to have MathJax select the output processor for
you so that MathML is used in those browsers that support it well
enough, while HTML-CSS is used for those that don't. See the
:ref:`common configurations <common-configurations>` section for
details and examples.
Of course it is also possible to use all three components together.
It may seem strange to go through an internal format just to return to
MathML in the end, but this is actually what makes it possible to view
MathML within an HTML page (rather than an XHTML page), without
the complications of handling special MIME-types for the document, or
any of the other setup issues that make using native MathML
difficult. MathJax handles the setup and properly marks the
mathematics so that the browser will render it as MathML. In
addition, MathJax provides its contextual menu for the MathML, which
lets the user zoom the mathematics for easier reading, get and copy
the source markup, and so on, so there is added value to using MathJax
even with a pure MathML workflow.
MathML in HTML pages
====================
For MathML that is handled via the preprocessor, you should not use
named MathML entities, but rather use numeric entities like
``&#x221A;`` or unicode characters embedded in the page itself. The
reason is that entities are replaced by the browser before MathJax
runs, and some browsers report errors for unknown entities. For
browsers that are not MathML-aware, that will cause errors to be
displayed for the MathML entities. While that might not occur in the
browser you are using to compose your pages, it can happen with other
browsers, so you should avoid the named entities whenever possible.
If you must use named entities, you may need to declare them in the
`DOCTYPE` declaration by hand.
When you use MathML in an HTML document rather than an XHTML one
(MathJax will work woth both), you should not use the "self-closing"
form for tags with no content, but should use separate open and close
tags. That is, use
.. code-block:: html
<mspace width="thinmathspace"></mspace>
rather than ``<mspace width="thinmathspace />``. This is because HTML
(prior to HTML5) does not have self-closing tags, and some browsers
will get the nesting of tags wrong if you attempt to use them. For
example, with ``<mspace width="1em" />``, since there is no closing
tag, the rest of the mathematics will become the content of the
``<mspace>`` tag; but since ``<mspace>`` should have no content, the
rest of the mathematics will not be displayed. This is a common error
that should be avoided. Modern browsers that support HTML5 should be
able to handle self-closing tags, but older browsers have problems
with them, so if you want your mathematics to be visible to the widest
audience, do not use the self-closing form in HTML documents.
Supported MathML commands
=========================
MathJax supports the `MathML3.0 <http://www.w3.org/TR/MathML3/>`_
presentation mathematics tags, with some limitations. The MathML
support is still under active development, so some tags are not yet
implemented, and some features are not fully developed, but are
coming.
The deficiencies include:
- No support for the elementary math tags: ``mstack``, ``mlongdiv``,
``msgroup``, ``msrow``, ``mscarries``, and ``mscarry``.
- No support for alignment groups in tables.
- No support for right-to-left rendering.
- Not all attributes are supported for tables. E.g., ``columnspan``
and ``rowspan`` are not implemented yet.
See the `results of the MathML3.0 test suite
<http://www.w3.org/Math/testsuite/results/tests.html>`_ for details.

238
docs/html/_sources/model.txt
View File

@ -1,238 +0,0 @@
****************************
The MathJax Processing Model
****************************
The purpose of MathJax is to bring the ability to include mathematics
easily in web pages to as wide a range of browsers as possible.
Authors can specify mathematics in a variety of formats (e.g.,
:term:`MathML`, :term:`LaTeX`, or :term:`AsciiMath`), and MathJax provides high-quality
mathematical typesetting even in those browsers that do not have
native MathML support. This all happens without the need for special
downloads or plugins, but rendering will be enhanced if high-quality
math fonts (e.g., :term:`STIX`) are available to the browser.
MathJax is broken into several different kinds of components: page
preprocessors, input processors, output processors, and the MathJax
Hub that organizes and connects the others. The input and output
processors are called :term:`jax`, and are described in more detail
below.
When MathJax runs, it looks through the page for special tags that
hold mathematics; for each such tag, it locates an appropriate input
jax which it uses to convert the mathematics into an internal form
(called an element jax), and then calls an output jax to transform the
internal format into HTML content that displays the mathematics within
the page. The page author configures MathJax by indicating which
input and output jax are to be used.
Often, and especially with pages that are authored by hand, the
mathematics is not stored (initially) within the special tags needed
by MathJax, as that would require more notation than the average page
author is willing to type. Instead, it is entered in a form that is
more natural to the page author, for example, using the standard TeX
math delimiters ``$...$`` and ``$$...$$`` to indicate what part of the
document is to be typeset as mathematics. In this case, MathJax can
run a preprocessor to locate the math delimiters and replace them by
the special tags that it uses to mark the formulas. There are
preprocessors for :ref:`TeX notation <TeX-support>`, :ref:`MathML
notation <MathML-support>`, :ref:`AsciiMath notation
<AsciiMath-support>` and the :ref:`jsMath notation
<jsMath-support>` that uses `span` and `div` tags.
For pages that are constructed programmatically, such as HTML
pages that result from running a processor on text in some other
format (e.g., pages produced from Markdown documents, or via programs
like `tex4ht`), it would be best to use MathJax's special tags
directly, as described below, rather than having MathJax run
another preprocessor. This will speed up the final display of the
mathematics, since the extra preprocessing step would not be needed.
It also avoids the conflict between the use of the less-than sign,
``<``, in mathematics and as an HTML special character (that starts
an HTML tag), and several other issues involved in having the
mathematics directly in the text of the page (see the documentation on
the various input jax for more details on this).
.. _mathjax-script-tags:
How mathematics is stored in the page
=====================================
In order to identify mathematics in the page, MathJax uses special
``<script>`` tags to enclose the mathematics. This is done because
such tags can be located easily, and because their content is not
further processed by the browser; for example, less-than signs can be
used as they are in mathematics, without worrying about them being
mistaken for the beginnings of HTML tags. One may also consider the
math notation as a form of "script" for the mathematics, so a
``<script>`` tag makes at least some sense for storing the math.
Each ``<script>`` tag has a ``type`` attribute that identifies the
kind of script that the tag contains. The usual (and default) value
is ``type="text/javascript"``, and when a script has this type, the
browser executes the script as a javascript program. MathJax,
however, uses the type `math/tex` to identify mathematics in the TeX
and LaTeX notation, `math/mml` for mathematics in MathML notation, and
`math/asciimath` for mathematics in AsciiMath notation. When the
`tex2jax`, `mml2jax`, or `asciimath2jax` preprocessors run, they
create ``<script>`` tags with these types so that MathJax can process
them when it runs its main typesetting pass.
For example,
.. code-block:: html
<script type="math/tex">x+\sqrt{1-x^2}</script>
represents an in-line equation in TeX notation, and
.. code-block:: html
<script type="math/tex; mode=display">
\sum_{n=1}^\infty {1\over n^2} = {\pi^2\over 6}
</script>
is a displayed TeX equation.
Alternatively, using MathML notation, you could use
.. code-block:: html
<script type="math/mml">
<math>
<mi>x</mi>
<mo>+</mo>
<msqrt>
<mn>1</mn>
<mo>&#x2212;<!-- − --></mo>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</msqrt>
</math>
</script>
for in-line math, or
.. code-block:: html
<script type="math/mml">
<math display="block">
<mrow>
<munderover>
<mo>&#x2211;<!-- ∑ --></mo>
<mrow>
<mi>n</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mi mathvariant="normal">&#x221E;<!-- ∞ --></mi>
</munderover>
</mrow>
<mrow>
<mfrac>
<mn>1</mn>
<msup>
<mi>n</mi>
<mn>2</mn>
</msup>
</mfrac>
</mrow>
<mo>=</mo>
<mrow>
<mfrac>
<msup>
<mi>&#x03C0;<!-- π --></mi>
<mn>2</mn>
</msup>
<mn>6</mn>
</mfrac>
</mrow>
</math>
</script>
for displayed equations in MathML notation.
As other input jax are created, they will use other types to identify
the mathematics they can process.
Page authors can use one of MathJax's preprocessors to convert from
math delimiters that are more natural for the author to type (e.g.,
TeX math delimiters like ``$$...$$``) to MathJax's ``<script>``
format. Blog and wiki software could extend from their own markup
languages to include math delimiters, which they could convert to
MathJax's ``<script>`` format automatically.
Note, however, that Internet Explorer has a bug that causes it to
remove the space before a ``<script>`` tag if there is also a space
after it, which can cause serious spacing problems with in-line math
in Internet Explorer. There are three possible solutions to this in
MathJax. The recommended way is to use a math preview (an element
with class ``MathJax_Preview``) that is non-empty and comes right
before the ``<script>`` tag. Its contents can be just the word
``[math]``, so it does not have to be specific to the mathematics
script that follows; it just has to be non-empty (though it could have
its style set to ``display:none``). See also the ``preJax`` and
``postJax`` options in the :ref:`Core Configuration Options
<configure-hub>` document for another approach.
The components of MathJax
=========================
The main components of MathJax are its preprocessors, its input and
output jax, and the MathJax Hub, which coordinates the actions of the
other components.
**Input jax** are associated with the different script types (like
:mimetype:`math/tex` or :mimetype:`math/mml`) and the mapping of a
particular type to a particular jax is made when the various jax
register their abilities with the MathJax Hub at configuration time.
For example, the MathML input jax registers the :mimetype:`math/mml`
type, so MathJax will know to call the MathML input jax when it sees
math elements of that type. The role of the input jax is to convert
the math notation entered by the author into the internal format used
by MathJax (called an `element jax`). This internal format is
essentially MathML (represented as JavaScript objects), so an input
jax acts as a translator into MathML.
**Output jax** convert that internal element jax format into a
specific output format. For example, the NativeMML output jax inserts
MathML tags into the page to represent the mathematics, while the
HTML-CSS output jax uses HTML with CSS styling to lay out the
mathematics so that it can be displayed even in browsers that don't
understand MathML. MathJax also has an :term:`SVG` output jax that
will render the mathematics using scalable vector grtaphics. Output
jax could be produced that render the mathematics using HTML5 canvas
elements, for example, or that speak an equation for blind users. The
MathJax contextual menu can be used to switch between the output jax
that are available.
Each input and output jax has a small configuration file that is
loaded when that input jax is included in the `jax` array in the
MathJax configuration, and a larger file that implements the core
functionality of that particular jax. The latter file is loaded the
first time the jax is needed by MathJax to process some mathematics.
Most of the combined configuration files include only the small
configuration portion for the input and output jax, making the
configuraiton file smaller and faster to load for those pages that
don't actually incldue mathematics; the combined configurations that
end in ``-full`` include both parts of the jax, so there is no delay
when the math is to be rendered, but at the expense of a larger
initial download.
The **MathJax Hub** keeps track of the internal representations of the
various mathematical equations on the page, and can be queried to
obtain information about those equations. For example, one can obtain
a list of all the math elements on the page, or look up a particular
one, or find all the elements with a given input format, and so on.
In a dynamically generated web page, an equation where the source
mathematics has changed can be asked to re-render itself, or if a new
paragraph is generated that might include mathematics, MathJax can be
asked to process the equations it contains.
The Hub also manages issues concerning mouse events and other user
interaction with the equation itself. Parts of equations can be made
active so that mouse clicks cause event handlers to run, or activate
hyperlinks to other pages, and so on, making the mathematics as
dynamic as the rest of the page.

41
docs/html/_sources/options/AsciiMath.txt
View File

@ -1,41 +0,0 @@
.. _configure-AsciiMath:
*****************************
The AsciiMath input processor
*****************************
The options below control the operation of the AsciiMath input
processor that is run when you include ``"input/AsciiMath"`` in the
`jax` array of your configuration or load a combined configuration
file that includes the AsciiMath input jax. They are listed with
their default values. To set any of these options, include a
``AsciiMath`` section in your :meth:`MathJax.Hub.Config()` call. For
example
.. code-block:: javascript
MathJax.Hub.Config({
AsciiMath: {
displaystyle: false
}
});
would set the ``displaystyle`` configuration option so that the limits
for operators like summation symbols will appear next to them rather
than above and below.
.. describe:: displaystyle: true
Determines whether operators like summation symbols will have
their limits above and below the operators (true) or to their
right (false). The former is how they would appear in displayed
equations that appear on their own lines, while the latter is
better suited to in-line equations so that they don't interfere
with the line spacing so much.
.. describe:: decimal: "."
This is the character to be used for decimal points in numbers.
if you change this to ``","``, then you need to be careful about
entering points or intervals. E.g., use ``(1, 2)`` rather than
``(1,2)`` in that case.

143
docs/html/_sources/options/FontWarnings.txt
View File

@ -1,143 +0,0 @@
.. _configure-FontWarnings:
**************************
The FontWarnings extension
**************************
The options below control the operation of the `FontWarnings`
extension that is run when you include ``"FontWarnings.js"`` in the
`extensions` array of your configuration. They are listed with their
default values. To set any of these options, include a
``FontWarnings`` section in your :meth:`MathJax.Hub.Config()` call.
For example
.. code-block:: javascript
MathJax.Hub.Config({
FontWarnings: {
fadeoutTime: 2*1000
}
});
would set the ``fadeoutTime`` option to 2000 milliseconds (2 seconds).
.. describe:: messageStyle: { ... }
This sets the CSS styles to be used for the font warning message
window. See the ``extensions/FontWarnings.js`` file for details of
what are set by default. See the :ref:`CSS style objects
<css-style-objects>` for details about how to specify CSS styles
via javascript objects.
.. describe:: Message: { ... }
This block contains HTML snippets to be used for the various
messages that the FontWarning extension can produce. There are
three messages that you can redefine to suit your needs:
.. describe:: webFont: [ ... ]
The message used for when MathJax uses web-based fonts (rather
than local fonts installed on the user's system).
.. describe:: imageFonts: [ ... ]
The message used for when MathJax must use image fonts rather
than local or web-based fonts (for those browsers that don't
handle the ``@font-face`` CSS directive).
.. describe:: noFonts: [ ... ]
The message used when MathJax is unable to find any font to use
(i.e., neither local nor web-based nor image-based fonts are
available).
Any message that is set to ``null`` rather than an HTML snippet
array will not be presented to the user, so you can set, for
example, the ``webFont`` message to ``null`` in order to have the
``imageFonts`` and ``noFonts`` messages, but no message if MathJax
uses web-based fonts.
See the description of :ref:`HTML snippets <html-snippets>` for
details about how to describe the messages using HTML snippets.
Note that in addition to the usual rules for defining such
snippets, the FontWarnings snippets can include references to
pre-defined snippets (that represent elements common to all three
messages). These are defined below in the ``HTML`` block, and are
referenced using ``["name"]`` within the snippet, where `name` is
the name of one of the snippets defined in the ``HTML``
configuration block. For example
.. code-block:: javascript
Message: {
noFonts: [
["closeBox"],
"MathJax is unable to locate a font to use to display ",
"its mathematics, and image fonts are not available, so it ",
"is falling back on generic unicode characters in hopes that ",
"your browser will be able to display them. Some characters ",
"may not show up properly, or possibly not at all.",
["fonts"],
["webfonts"]
]
}
refers to the ``closeBox``, ``fonts`` and ``webfonts`` snippets
declared in the ``HTML`` section.
.. describe:: HTML: { ... }
This object defines HTML snippets that are common to more than one
message in the ``Message`` section above. They can be included in
other HTML snippets by by using ``["name"]`` in an HTML snippet,
where `name` refers to the name of the snippet in the ``HTML``
block. The pre-defined snippets are:
.. describe:: closeBox
The HTML for the close box in the FontWarning message.
.. describe:: webfonts
The HTML for a paragraph suggesting an upgrade to a more
modern browser that supports web fonts.
.. describe:: fonts
HTML that includes links to the MathJax and STIX font download
pages.
.. describe:: STIXfonts
HTML that gives the download link for the STIX fonts only.
(Used in place of `fonts` when the `HTML-CSS` option for
`availableFonts` only includes the :term:`STIX` fonts.)
.. describe:: TeXfonts
HTML that gives the download link for the MathJax TeX fonts
only. (Used in place of `fonts` when the `HTML-CSS` option
for `availableFonts` only includes the `TeX` fonts.)
You can add your own pre-defined HTML snippets to this object, or
override the ones that are there with your own text.
.. describe:: removeAfter: 12*1000
This is the amount of time to show the FontWarning message, in
milliseconds. The default is 12 seconds. Setting this value
to zero means that the message will not fade out (the user must
close it manually).
.. describe:: fadeoutSteps: 10
This is the number of steps to take while fading out the
FontWarning message. More steps make for a smoother fade-out.
Set to zero to cause the message to be removed without fading.
.. describe:: fadeoutTime: 1.5*1000
This is the time used to perform the fade-out, in milliseconds.
The default is 1.5 seconds.

191
docs/html/_sources/options/HTML-CSS.txt
View File

@ -1,191 +0,0 @@
.. _configure-HTML-CSS:
*****************************
The HTML-CSS output processor
*****************************
The options below control the operation of the HTML-CSS output
processor that is run when you include ``"output/HTML-CSS"`` in the
`jax` array of your configuration or load a combined configuration
file that includes the HTML-CSS output jax. They are listed with
their default values. To set any of these options, include a
``"HTML-CSS"`` section in your :meth:`MathJax.Hub.Config()` call.
Note that, because of the dash, you need to enclose the name in
quotes. For example
.. code-block:: javascript
MathJax.Hub.Config({
"HTML-CSS": {
preferredFont: "STIX"
}
});
would set the ``preferredFont`` option to the :term:`STIX` fonts.
.. describe:: scale: 100
The scaling factor (as a percentage) of math with respect to the
surrounding text. The `HTML-CSS` output processor tries to match
the ex-size of the mathematics with that of the text where it is
placed, but you may want to adjust the results using this scaling
factor. The user can also adjust this value using the contextual
menu item associated with the typeset mathematics.
.. describe:: minScaleAdjust: 50
This gives a minimum scale (as a percent) for the scaling used by
MathJax to match the equation to the surrounding text. This will
prevent MathJax from making the mathematics too small.
.. describe:: availableFonts: ["STIX","TeX"]
This is a list of the fonts to look for on a user's computer in
preference to using MathJax's web-based fonts. These must
correspond to directories available in the
``jax/output/HTML-CSS/fonts`` directory, where MathJax stores data
about the characters available in the fonts. Set this to
``["TeX"]``, for example, to prevent the use of the :term:`STIX`
fonts, or set it to an empty list, `[]`, if you want to force
MathJax to use web-based or image fonts.
.. describe:: preferredFont: "TeX"
Which font to prefer out of the ``availableFonts`` list, when more
than one is available on the user's computer.
.. describe:: webFont: "TeX"
This is the web-based font to use when none of the fonts listed
above are available on the user's computer. Note that currently
only the `TeX` font is available in a web-based form (they are
stored in the ``fonts/HTML-CSS`` folder in the MathJax directory).
Set this to ``null`` to disable web fonts.
.. describe:: imageFont: "TeX"
This is the font to use for image fallback mode (when none of the
fonts listed above are available and the browser doesn't support
web-fonts via the ``@font-face`` CSS directive). Note that currently
only the TeX font is available as an image font (they are stored
in the ``fonts/HTML-CSS`` directory).
Set this to ``null`` if you want to prevent the use of image fonts
(e.g., you have deleted or not installed the image fonts on your
server). In this case, only browsers that support web-based fonts
will be able to view your pages without having the fonts installed
on the client computer. The browsers that support web-based fonts
include: IE6 and later, Chrome, Safari3.1 and above, Firefox3.5
and later, and Opera10 and later. Note that Firefox3.0 is **not**
on this list.
.. describe:: undefinedFamily: "STIXGeneral, 'Arial Unicode MS', serif"
This is the font-family CSS value used for characters that are not
in the selected font (e.g., for web-based fonts, this is where to
look for characters not included in the MathJax web fonts). IE
will stop looking after the first font that exists on the system
(even if it doesn't contain the needed character), so order these
carefully.
.. describe:: mtextFontInherit: false
This setting controls whether ``<mtext>`` elements will be typeset
using the math fonts or the font of the surrounding text. When
``false``, the font for ``mathvariant="normal"`` will be used;
when ``true``, the font will be inherited from the surrounding
paragraph.
.. describe:: EqnChunk: 50
EqnChunkFactor: 1.5
EqnChunkDelay: 100
These values control how "chunky" the display of mathematical
expressions will be; that is, how often the equations will be
updated as they are processed.
``EqnChunk`` is the number of equations that will be typeset before
they appear on screen. Larger values make for less visual flicker
as the equations are drawn, but also mean longer delays before the
reader sees anything.
``EqChunkFactor`` is the factor by which the ``EqnChunk`` will
grow after each chunk is displayed.
``EqChunkDelay`` is the time (in milliseconds) to delay between
chunks (to allow the browser to respond to other user
interaction).
Set ``EqnChunk`` to 1, ``EqnChunkFactor`` to 1, and
``EqnChunkDelay`` to 10 to get the behavior from MathJax v1.1 and
below.
.. describe:: linebreaks: {}
This is an object that configures automatic linebreaking in the
HTML-CSS output. In order to be backward compatible with earlier
versions of MathJax, only explicit line breaks are performed by
default, so you must enable line breaks if you want automatic
ones. The object contains the following values:
.. describe:: automatic: false
This controls the automatic breaking of expressions: when
``false``, only ``linebreak="newline"`` is processed; when
``true``, line breaks are inserted automatically in long
expressions.
.. describe:: width: "container"
This controls how wide the lines of mathematics can be.
Use an explicit width like ``"30em"`` for a fixed width.
Use ``"container"`` to compute the size from the containing
element.
Use ``"nn% container"`` for a portion of the container.
Use ``"nn%"`` for a portion of the window size.
The container-based widths may be slower, and may not produce
the expected results if the layout width changes due to the
removal of previews or inclusion of mathematics during
typesetting.
.. describe:: styles: {}
This is a list of CSS declarations for styling the HTML-CSS
output. See the definitions in ``jax/output/HTML-CSS/config.js``
for some examples of what are defined by default. See :ref:`CSS
Style Objects <css-style-objects>` for details on how to specify
CSS style in a JavaScript object.
.. describe:: showMathMenu: true
This value has been moved to the core configuration block, since
it applies to all output jax, but it will still be honored (for
now) if it is set here. See the :ref:`Core configuration options
<configure-hub>` for more details.
.. describe:: tooltip: { ... }
This sets the configuration options for ``<maction>`` elements
with ``actiontype="tooltip"``. (See also the ``#MathJax_Tooltip``
style setting in ``jax/output/HTML-CSS/config.js``, which can be
overridden using the ``styles`` option above.)
The ``tooltip`` section can contain the following options:
.. describe:: delayPost: 600
The delay (in milliseconds) before the tooltip is posted after
the mouse is moved over the ``maction`` element.
.. describe:: delayClear: 600
The delay (in milliseconds) before the tooltop is cleared
after the mouse moves out of the ``maction`` element.
.. describe:: offsetX: 10
offsetY: 5
These are the offset from the mouse position (in pixels)
where the tooltip will be placed.

58
docs/html/_sources/options/MMLorHTML.txt
View File

@ -1,58 +0,0 @@
.. _configure-MMLorHTML:
***********************************
The MMLorHTML configuration options
***********************************
The options below control the operation of the MMLorHTML configuration
file that is run when you include ``"MMLorHTML.js"`` in the `config`
array of your configuration, or when you use one of the combined
configuration files that ends with ``_HTMLorMML``. They are listed
with their default values. To set any of these options, include a
``MMLorHTML`` section in your :meth:`MathJax.Hub.Config()` call. For
example
.. code-block:: javascript
MathJax.Hub.Config({
MMLorHTML: {
prefer: {
Opera: "MML"
}
}
});
would set the ``prefer`` option so that the Opera browser would prefer
MathML to HTML-CSS output (while leaving the settings for other
browsers unchanged).
Note that if you use the ``MMLorHTML.js`` configuration file, you should
**not** specify an output processor in the `jax` array of your
configuration; `MMLorHTML` will fill that in for you.
.. describe:: prefer: {
MSIE: "MML",
Firefox: "HTML",
Safari: "HTML",
Chrome: "HTML",
Opera: "HTML",
other: "HTML"
}
This lets you set the preferred renderer on a browser-by-browser
basis. You set the browser to either ``"MML"`` or ``"HTML"``
depending on whether you want to use the `NativeMML` or `HTML-CSS`
output processor. Note that although Opera and Safari do process some MathML
natively, their support is not sufficient to handle the more
complicated output generated by MathJax, so their settings are
``"HTML"`` by default. Although Firefox does support a large
subset of MathJax, it does not implement all the features needed by
MathJax, and so it is also set to ``"HTML"`` by default (this is
new in v2.0).
Note that users can still use the MathJax contextual menu to select
a different renderer after the default one has been chosen by
``MMLorHTML.js``.

37
docs/html/_sources/options/MathEvents.txt
View File

@ -1,37 +0,0 @@
.. _configure-MathEvents:
************************
The MathEvents extension
************************
The options below control the operation of the MathEvents component that
allows handles mouse and menu events attached to mathematics that is
typeset by MathJax. They are listed with their
default values. To set any of these options, include a ``MathEvents``
section in your :meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
MathEvents: {
hover: 400
}
});
would set the required delay for hovering over a math element to
400 milliseconds.
.. describe:: hover: 500
This value is the time (in milliseconds) that a user must hold the
mouse still over a math element before it is considered to be
hovering over the math.
.. describe:: styles: {}
This is a list of CSS declarations for styling the zoomed
mathematics. See the definitions in ``extensions/MathEvents.js``
for details of what are defined by default. See :ref:`CSS Style
Objects <css-style-objects>` for details on how to specify CSS
style in a JavaScript object.

28
docs/html/_sources/options/MathML.txt
View File

@ -1,28 +0,0 @@
.. _configure-MathML:
**************************
The MathML input processor
**************************
The options below control the operation of the MathML input processor
that is run when you include ``"input/MathML"`` in the `jax` array of
your configuration or load a combined configuration file that includes
the MathML input jax. They are listed with their default values. To
set any of these options, include a ``MathML`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
MathML: {
useMathMLspacing: true
}
});
would set the ``useMathMLspacing`` option so that the MathML rules for
spacing would be used (rather than TeX spacing rules).
.. describe:: useMathMLspacing: false
Specifies whether to use TeX spacing or MathML spacing when the
`HTML-CSS` output jax is used.

87
docs/html/_sources/options/MathMenu.txt
View File

@ -1,87 +0,0 @@
.. _configure-MathMenu:
**********************
The MathMenu extension
**********************
The options below control the operation of the contextual menu that is
available on mathematics that is typeset by MathJax.
They are listed with their default values. To set any of these
options, include a ``MathMenu`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
MathMenu: {
delay: 600
}
});
would set the ``delay`` option to 600 milliseconds.
.. describe:: delay: 150
This is the hover delay for the display (in milliseconds) for
submenus in the contextual menu: when the mouse is over a submenu
label for this long, the menu will appear. (The submenu also will
appear if you click on its label.)
.. describe:: helpURL: "http://www.mathjax.org/help/user/"
This is the URL for the MathJax Help menu item. When the user
selects that item, the browser opens a new window with this URL.
.. describe:: showRenderer: true
This controls whether the "Math Renderer" item will be displayed
in the "Math Settings" submenu of the MathJax contextual menu.
It allows the user to change between the `HTML-CSS`, `NativeMML`,
and `SVG` output processors for the mathematics on the page. Set
to ``false`` to prevent this menu item from showing.
.. describe:: showFontMenu: false
This controls whether the "Font Preference" item will be displayed
in the "Math Settings" submenu of the MathJax contextual menu.
This submenu lets the user select what font to use in the
mathematics produced by the `HTML-CSS` output processor. Note that
changing the selection in the font menu will cause the page to
reload. Set to ``false`` to prevent this menu item from showing.
.. describe:: showMathPlayer: true
This controls whether the "MathPlayer" item will be displayed in
the "Math Settings" submenu of the MathJax contextual menu. This
submenu lets the user select what events should be passed on to
the `MathPlayer plugin
<http://www.dessci.com/en/products/mathplayer/>`_, when it is
present. Mouse events can be passed on (so that clicks will be
processed by MathPlayer rather than MathJax), and emnu events can
be passed on (to allow the user access to the MathPlayer menu).
Set to ``false`` to prevent this menu item from showing.
.. describe:: showContext: false
This controls whether the "Contextual Menu" item will be displayed
in the "Math Settings" submenu of the MathJax contextual menu.
It allows the user to decide whether the MathJax menu or the
browser's default contextual menu will be shown when the context
menu click occurs over mathematics typeset by MathJax. Set to
``false`` to prevent this menu item from showing.
.. describe:: windowSettings: { ... }
These are the settings for the ``window.open()`` call that
creates the `Show Source` window. The initial width and height
will be reset after the source is shown in an attempt to make the
window fit the output better.
.. describe:: styles: {}
This is a list of CSS declarations for styling the menu
components. See the definitions in ``extensions/MathMenu.js`` for
details of what are defined by default. See :ref:`CSS Style
Objects <css-style-objects>` for details on how to specify CSS
style in a JavaScript object.

47
docs/html/_sources/options/MathZoom.txt
View File

@ -1,47 +0,0 @@
.. _configure-MathZoom:
**********************
The MathZoom extension
**********************
The options below control the operation of the Math-Zoom feature that
allows users to see an enlarged version of the mathematics when they
click or hover over typeset mathematics. They are listed with their
default values. To set any of these options, include a ``MathZoom``
section in your :meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
MathZoom: {
styles: {
"#MathJax_Zoom": {
"background-color": "#0000F0"
}
}
}
});
would set the background color of the Zoom box to a very light blue.
Mathematics is zoomed when the user "triggers" the zoom by an action,
either clicking on the mathematics, double-clicking on it, or holding
the mouse still over it (i.e., "hovering"). Which trigger is used is
set by the user via the math contextual menu (or by the author using
the ``menuSettings`` configuration section of the `core configuration
options <configure-hub>`).
.. describe:: delay: 500
This value is now stored as the ``hover`` parameter in the
:ref:`MathEvents <configure-MathEvents>` configuration options, and
will have no effect if given here.
.. describe:: styles: {}
This is a list of CSS declarations for styling the zoomed
mathematics. See the definitions in ``extensions/MathZoom.js``
for details of what are defined by default. See :ref:`CSS Style
Objects <css-style-objects>` for details on how to specify CSS
style in a JavaScript object.

54
docs/html/_sources/options/NativeMML.txt
View File

@ -1,54 +0,0 @@
.. _configure-NativeMML:
******************************
The NativeMML output processor
******************************
The options below control the operation of the NativeMML output
processor that is run when you include ``"output/NativeMML"`` in the
`jax` array of your configuration or load a combined configuration
file taht includes the NativeMML output jax. They are listed with
their default values. To set any of these options, include a
``NativeMML`` section in your :meth:`MathJax.Hub.Config()` call. For
example
.. code-block:: javascript
MathJax.Hub.Config({
NativeMML: {
scale: 105
}
});
would set the ``scale`` option to 105 percent.
.. describe:: scale: 100
The scaling factor (as a percentage) of math with respect to the
surrounding text. The `NativeMML` output processor tries to match
the ex-size of the mathematics with that of the text where it is
placed, but you may want to adjust the results using this scaling
factor. The user can also adjust this value using the contextual
menu item associated with the typeset mathematics.
.. describe:: minScaleAdjust: 50
This gives a minimum scale (as a percent) for the scaling used by
MathJax to match the equation to the surrounding text. This will
prevent MathJax from making the mathematics too small.
.. describe:: showMathMath: true
showMathMenuMSIE: true
These values have been moved to the core configuration block, since
it applies to all output jax, but they will still be honored (for
now) if it is set here. See the :ref:`Core configuration options
<configure-hub>` for more details.
.. describe:: styles: {}
This is a list of CSS declarations for styling the NativeMML
output. See the definitions in ``jax/output/NativeMML/config.js``
for some examples of what are defined by default. See :ref:`CSS
Style Objects <css-style-objects>` for details on how to specify
CSS style in a JavaScript object.

162
docs/html/_sources/options/SVG.txt
View File

@ -1,162 +0,0 @@
.. _configure-SVG:
************************
The SVG output processor
************************
The options below control the operation of the SVG output
processor that is run when you include ``"output/SVG"`` in the
`jax` array of your configuration or load a combined configuration
file that includes the SVG output jax. They are listed with their default
values. To set any of these options, include an ``SVG`` section
in your :meth:`MathJax.Hub.Config()` call. Note that, because of the
dash, you need to enclose the name in quotes. For example
.. code-block:: javascript
MathJax.Hub.Config({
"SVG": {
scale: 120
}
});
would set the ``scale`` option to 120%.
.. describe:: scale: 100
The scaling factor (as a percentage) of math with respect to the
surrounding text. The `SVG` output processor tries to match
the ex-size of the mathematics with that of the text where it is
placed, but you may want to adjust the results using this scaling
factor. The user can also adjust this value using the contextual
menu item associated with the typeset mathematics.
.. describe:: minScaleAdjust: 50
This gives a minimum scale (as a percent) for the scaling used by
MathJax to match the equation to the surrounding text. This will
prevent MathJax from making the mathematics too small.
.. describe:: font: "TeX"
This is the font to use for rendering the mathematics. Note that
currently only the `TeX` font is available.
.. describe:: blacker: 10
This is the stroke width to use for all character paths (1em =
1000 units). This is a cheap way of getting slightly lighter or
darker characters, but remember that not all displays will act the
same, so a value that is good for you may not be good for everyone.
.. describe:: undefinedFamily: "STIXGeneral, 'Arial Unicode MS', serif"
This is the font-family CSS value used for characters that are not
in the selected font (e.g., this is where to look for characters
not included in the MathJax TeX fonts). IE will stop looking
after the first font that exists on the system (even if it doesn't
contain the needed character), so order these carefully.
.. describe:: mtextFontInherit: false
This setting controls whether ``<mtext>`` elements will be typeset
using the math fonts or the font of the surrounding text. When
``false``, the font for ``mathvariant="normal"`` will be used;
when ``true``, the font will be inherited from the surrounding
paragraph.
.. describe:: addMMLclasses: false
This controls whether the MathML structure is retained and CSS
classes are added to mark the original MathML elements (as in the
output from the `HTML-CSS` output jax). By default, the SVG
output jax removes unneeded nesting in order to produce a more
efficient markup, but if you want to use CSS to style the elements
as if they were MathML, you might need to set this to true.
.. describe:: EqnChunk: 50
EqnChunkFactor: 1.5
EqnChunkDelay: 100
These values control how "chunky" the display of mathematical
expressions will be; that is, how often the equations will be
updated as they are processed.
``EqnChunk`` is the number of equations that will be typeset before
they appear on screen. Larger values make for less visual flicker
as the equations are drawn, but also mean longer delays before the
reader sees anything.
``EqChunkFactor`` is the factor by which the ``EqnChunk`` will
grow after each chunk is displayed.
``EqChunkDelay`` is the time (in milliseconds) to delay between
chunks (to allow the browser to respond to other user
interaction).
Set ``EqnChunk`` to 1, ``EqnChunkFactor`` to 1, and
``EqnChunkDelay`` to 10 to get the behavior from MathJax v1.1 and
below.
.. describe:: linebreaks: {}
This is an object that configures automatic linebreaking in the
SVG output. In order to be backward compatible with earlier
versions of MathJax, only explicit line breaks are performed by
default, so you must enable line breaks if you want automatic
ones. The object contains the following values:
.. describe:: automatic: false
This controls the automatic breaking of expressions: when
``false``, only ``linebreak="newline"`` is processed; when
``true``, line breaks are inserted automatically in long
expressions.
.. describe:: width: "container"
This controls how wide the lines of mathematics can be.
Use an explicit width like ``"30em"`` for a fixed width.
Use ``"container"`` to compute the size from the containing
element.
Use ``"nn% container"`` for a portion of the container.
Use ``"nn%"`` for a portion of the window size.
The container-based widths may be slower, and may not produce
the expected results if the layout width changes due to the
removal of previews or inclusion of mathematics during
typesetting.
.. describe:: styles: {}
This is a list of CSS declarations for styling the SVG output.
See the definitions in ``jax/output/SVG/config.js`` for some
examples of what are defined by default. See :ref:`CSS Style
Objects <css-style-objects>` for details on how to specify CSS
style in a JavaScript object.
.. describe:: tooltip: { ... }
This sets the configuration options for ``<maction>`` elements
with ``actiontype="tooltip"``. (See also the ``#MathJax_Tooltip``
style setting in ``jax/output/SVG/config.js``, which can be
overridden using the ``styles`` option above.)
The ``tooltip`` section can contain the following options:
.. describe:: delayPost: 600
The delay (in milliseconds) before the tooltip is posted after
the mouse is moved over the ``maction`` element.
.. describe:: delayClear: 600
The delay (in milliseconds) before the tooltop is cleared
after the mouse moves out of the ``maction`` element.
.. describe:: offsetX: 10
offsetY: 5
These are the offset from the mouse position (in pixels)
where the tooltip will be placed.

131
docs/html/_sources/options/TeX.txt
View File

@ -1,131 +0,0 @@
.. _configure-TeX:
***********************
The TeX input processor
***********************
The options below control the operation of the TeX input processor
that is run when you include ``"input/TeX"`` in the `jax` array of
your configuration or load a combined configuration file that includes
the TeX input jax. They are listed with their default values. To
set any of these options, include a ``TeX`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
TeX: {
Macros: {
RR: '{\\bf R}',
bold: ['{\\bf #1}', 1]
}
}
});
would set the ``Macros`` configuration option to cause two new macros
to be defined within the TeX input processor.
.. describe:: TagSide: "right"
This specifies the side on which ``\tag{}`` macros will place the
tags. Set it to ``"left"`` to place the tags on the left-hand side.
.. describe:: TagIndent: ".8em"
This is the amount of indentation (from the right or left) for the
tags produced by the ``\tag{}`` macro.
.. describe:: MultLineWidth: "85%"
The width to use for the `multline` environment that is part of
the ``AMSmath`` extension. This width gives room for tags at
either side of the equation, but if you are displaying mathematics
in a small area or a thin column of text, you might need to change
the value to leave sufficient margin for tags.
.. describe:: equationNumbers: {}
This object controls the automatic equation numbering and the
equation referencing. It contains the following values:
.. describe:: autoNumber: "none"
This controls whether equations are numbered and how. By
default it is set to ``"none"`` to be compatible with earlier
versions of MathJax where auto-numbering was not performed (so
pages will not change their appearance). You can change
this to ``"AMS"`` for equations numbered as the `AMSmath`
package would do, or ``"all"`` to get an equation number for
every displayed equation.
.. describe:: formatNumber: function (n) {return n}
A function that tells MathJax what tag to use for equation
number ``n``. This could be used to have the equations labeled
by a sequence of symbols rather than numbers, or to use section
and subsection numbers instead.
.. describe:: formatTag: function (n) {return '('+n+')'}
A function that tells MathJax how to format an equation number
for displaying as a tag for an equation. This is what appears
in the margin of a tagged or numbered equation.
.. describe:: formatID: function {return 'mjx-eqn-'+String(n).replace(/[:'"<>&]/g,"")}
A function that rells MathJax what ID to use as an anchor for
the equation (so that it can be used in URL references).
.. describe:: formatURL: function (id) {return '#'+escape(id)}
A function that takes an equation ID and returns the URL to
link to it.
.. describe:: useLabelIds: true
This controls whether element ID's use the ``\label`` name or
the equation number. When ``true``, use the label, when
``false``, use the equation number.
See the `MathJax examples page
<http://cdn.mathjax.org/mathjax/latest/test/examples.html>`_ for
some examples of equation numbering.
.. describe:: Macros: {}
This lists macros to define before the TeX input processor begins.
These are `name:value` pairs where the `name` gives the name of
the TeX macro to be defined, and `value` gives the replacement
text for the macro. The `value` can be an array of the form
`[value,n]`, where `value` is the replacement text and `n` is the
number of parameters for the macro. Note that since the `value`
is a javascript string, backslashes in the replacement text must
be doubled to prevent them from acting as javascript escape
characters.
For example,
.. code-block:: javascript
Macros: {
RR: '{\\bf R}',
bold: ['{\\bf #1}', 1]
}
would ask the TeX processor to define two new macros: ``\RR``,
which produces a bold-face "R", and ``\bold{...}``, which takes one
parameter and sets it in the bold-face font.
.. describe:: MAXMACROS: 10000
Because a definition of the form ``\def\x{\x} \x`` would cause MathJax
to loop infinitely, the `MAXMACROS` constant will limit the number of
macro substitutions allowed in any expression processed by MathJax.
.. describe:: MAXBUFFER: 5*1024
Because a definition of the form ``\def\x{\x aaa} \x`` would loop
infinitely, and at the same time stack up lots of a's in MathJax's
equation buffer, the `MAXBUFFER` constant is used to limit the size of
the string being processed by MathJax. It is set to 5KB, which should
be sufficient for any reasonable equation.

110
docs/html/_sources/options/asciimath2jax.txt
View File

@ -1,110 +0,0 @@
.. _configure-asciimath2jax:
******************************
The asciimath2jax Preprocessor
******************************
The options below control the operation of the `asciimath2jax` preprocessor
that is run when you include ``"asciimath2jax.js"`` in the `extensions` array
of your configuration. They are listed with their default values. To
set any of these options, include a ``asciimath2jax`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
asciimath2jax: {
delimiters: [['`','`'], ['$','$']]
}
});
would set the ASCIIMath delimiters for the `asciimath2jax`
preprocessor to include dollar signs as well as back-ticks.
.. describe:: delimiters: [['`','`']]
Array of pairs of strings that are to be used as math
delimiters. The first in each pair is the initial delimiter and
the second is the terminal delimiter. You can have as many pairs
as you want. For example,
.. code-block:: javascript
inlineMath: [ ['$','$'], ['`','`'] ]
would cause `asciimath2jax` to look for ``$...$`` and ```...``` as
delimiters for inline mathematics. (Note that the single dollar
signs are not enabled by default because they are used too
frequently in normal text, so if you want to use them for math
delimiters, you must specify them explicitly.)
Note that the delimiters can't look like HTML tags (i.e., can't
include the less-than sign), as these would be turned into tags by
the browser before MathJax has the chance to run. You can only
include text, not tags, as your math delimiters.
.. describe:: preview: "AsciiMath"
This controls whether `asciimath2jax` inserts ``MathJax_Preview``
spans to make a preview available, and what preview to use, when
it locates in-line or display mathematics in the page. The
default is ``"AsciiMath"``, which means use the ASCIIMath code as
the preview (which will be visible until it is processed by
MathJax). Set to ``"none"`` to prevent previews from being
inserted (the math will simply disappear until it is typeset).
Set to an array containing the description of an HTML snippet in
order to use the same preview for all equations on the page.
Examples:
.. code-block:: javascript
preview: ["[math]"], // insert the text "[math]" as the preview
.. code-block:: javascript
preview: [["img",{src: "/images/mypic.jpg"}]], // insert an image as the preview
See the :ref:`description of HTML snippets <html-snippets>` for
details on how to represent HTML code in this way.
.. describe:: skipTags: ["script","noscript","style","textarea","pre","code"]
This array lists the names of the tags whose contents should not
be processed by `asciimath2jax` (other than to look for
ignore/process classes as listed below). You can add to (or
remove from) this list to prevent MathJax from processing
mathematics in specific contexts.
.. describe:: ignoreClass: "asciimath2jax_ignore"
This is the class name used to mark elements whose contents should
not be processed by asciimath2jax (other than to look for the
``processClass`` pattern below). Note that this is a regular
expression, and so you need to be sure to quote any `regexp`
special characters. The pattern is inserted into one that
requires your pattern to match a complete word, so setting
``ignoreClass: "class2"`` would cause it to match an element with
``class="class1 class2 class3"`` but not ``class="myclass2"``.
Note that you can assign several classes by separating them by the
vertical line character (``|``). For instance, with
``ignoreClass: "class1|class2"`` any element assigned a class of
either ``class1`` or ``class2`` will be skipped.
.. describe:: processClass: "asciimath2jax_process"
This is the class name used to mark elements whose contents
*should* be processed by `asciimath2jax`. This is used to restart
processing within tags that have been marked as ignored via the
``ignoreClass`` or to cause a tag that appears in the ``skipTags``
list to be processed rather than skipped. Note that this is a
regular expression, and so you need to be sure to quote any
`regexp` special characters. The pattern is inserted into one
that requires your pattern to match a complete word, so setting
``processClass: "class2"`` would cause it to match an element with
``class="class1 class2 class3"`` but not ``class="myclass2"``.
Note that you can assign several classes by separating them by the
vertical line character (``|``). For instance, with
``processClass: "class1|class2"`` any element assigned a class of
either ``class1`` or ``class2`` will have its contents processed.

279
docs/html/_sources/options/hub.txt
View File

@ -1,279 +0,0 @@
.. _configure-hub:
******************************
The Core Configuration Options
******************************
The options below control the MathJax Hub, and so determine the code
behavior of MathJax. They are given with their default values.
.. describe:: jax: ["input/TeX","output/HTML-CSS"]
A comma-separated list of input and output jax to initialize at
startup. Their main code is loaded only when they are actually
used, so it is not inefficient to include jax that may not
actually be used on the page. These are found in the ``MathJax/jax``
directory.
.. describe:: extensions: []
A comma-separated list of extensions to load at startup. The
default directory is ``MathJax/extensions``. The ``tex2jax`` and
``mml2jax`` preprocessors can be listed here, as well as a
``FontWarnings`` extension that you can use to inform your user
that mathematics fonts are available that they can download to
improve their experience of your site.
.. describe:: config: []
A comma-separated list of configuration files to load when MathJax
starts up, e.g., to define local macros, etc., and there is a
sample config file named ``config/local/local.js``. The default
directory is the `MathJax/config` directory. The ``MMLorHTML.js``
configuration is one such configuration file, and there are a
number of other pre-defined configurations (see :ref:`Using a
configuration file <config-files>` for more details).
.. describe:: styleSheets: []
A comma-separated list of CSS stylesheet files to be loaded when
MathJax starts up. The default directory is the `MathJax/config`
directory.
.. describe:: styles: {}
CSS styles to be defined dynamically at startup time. These are
in the form `selector:rules` (see :ref:`CSS Style Objects
<css-style-objects>` for complete details).
.. describe:: preJax: null and postJax: null
Patterns to remove from before and after math script tags. If you
are not using one of the preprocessors, you need to insert
something extra into your HTML file in order to avoid a bug in
Internet Explorer. IE removes spaces from the DOM that it thinks
are redundant, and since a ``<script>`` tag usually doesn't add
content to the page, if there is a space before and after a
MathJax ``<script>`` tag, IE will remove the first space. When
MathJax inserts the typeset mathematics, this means there will be
no space before it and the preceding text. In order to avoid
this, you should include some "guard characters" before or after
the math SCRIPT tag; define the patterns you want to use below.
Note that these are used as part of a regular expression, so you
will need to quote special characters. Furthermore, since they
are javascript strings, you must quote javascript special
characters as well. So to obtain a backslash, you must use ``\\``
(doubled for javascript). For example, ``"\\["`` represents the
pattern ``\[`` in the regular expression, or ``[`` in the text of
the web page. That means that if you want an actual backslash in
your guard characters, you need to use ``"\\\\"`` in order to get
``\\`` in the regular expression, and ``\`` in the actual text.
If both ``preJax`` and ``postJax`` are defined, both must be
present in order to be removed.
See also the ``preRemoveClass`` comments below.
Examples:
``preJax: "\\\\\\\\\"`` makes a double backslash the ``preJax`` text
``preJax: "\\[\\[", postJax: "\\]\\]"`` makes it so jax
scripts must be enclosed in double brackets.
.. describe:: preRemoveClass: "MathJax_Preview"
This is the CSS class name for math previews that will be removed
preceding a MathJax SCRIPT tag. If the tag just before the
MathJax ``<script>`` tag is of this class, its contents are
removed when MathJax processes the ``<script>`` tag. This allows
you to include a math preview in a form that will be displayed
prior to MathJax performing its typesetting. It also avoids the
Internet Explorer space-removal bug, and can be used in place of
``preJax`` and ``postJax`` if that is more convenient.
For example
.. code-block:: html
<span class="MathJax_Preview">[math]</span><script type="math/tex">...</script>
would display "[math]" in place of the math until MathJax is able
to typeset it.
See also the ``preJax`` and ``postJax`` comments above.
.. describe:: showProcessingMessages: true
This value controls whether the `Processing Math: nn%` messages are
displayed in the lower left-hand corner. Set to ``false`` to
prevent those messages (though file loading and other messages
will still be shown).
.. describe:: messageStyle: "normal"
This value controls the verbosity of the messages in the lower
left-hand corner. Set it to ``"none"`` to eliminate all messages,
or set it to ``"simple"`` to show "Loading..." and "Processing..."
rather than showing the full file name or the percentage of the
mathematics processed.
.. describe:: displayAlign: "center" and displayIndent: "0em"
These two parameters control the alignment and shifting of
displayed equations. The first can be ``"left"``, ``"center"``,
or ``"right"``, and determines the alignment of displayed
equations. When the alignment is not ``"center"``, the second
determines an indentation from the left or right side for the
displayed equations.
.. describe:: delayStartupUntil: "none"
Normally MathJax will perform its startup commands (loading of
configuration, styles, jax, and so on) as soon as it can. If you
expect to be doing additional configuration on the page, however,
you may want to have it wait until the page's onload handler is
called. If so, set this to ``"onload"``. You can also set this to
``"configured"``, in which case, MathJax will delay its startup until
you explicitly call :meth:`MathJax.Hub.Configured()`. See
:ref:`Configuring MathJax after it is loaded <delayStartupUntil>` for more
details.
.. describe:: skipStartupTypeset: false
Normally MathJax will typeset the mathematics on the page as soon
as the page is loaded. If you want to delay that process, in
which case you will need to call :meth:`MathJax.Hub.Typeset()`
yourself by hand, set this value to ``true``.
.. describe:: elements: []
This is a list of DOM element ID's that are the ones to process for
mathematics when any of the Hub typesetting calls (``Typeset()``, ``Process()``,
``Update()``, etc.) are called with no element specified, and during
MathJax's initial typesetting run when it starts up. This lets you
restrict the processing to particular containers rather than scanning
the entire document for mathematics. If none are supplied, the complete
document is processed.
.. describe:: positionToHash: true
Since typesetting usually changes the vertical dimensions of the
page, if the URL contains an anchor position, then after the page
is typeset, you may no longer be positioned at the correct
position on the page. MathJax can reposition to that location
after it completes its initial typesetting of the page. This
value controls whether MathJax will reposition the browser to the
``#hash`` location from the page URL after typesetting for the page.
.. describe:: showMathMenu: true
showMathMenuMSIE: true
These control whether to attach the MathJax contextual menu to the
expressions typeset by MathJax. Since the code for handling
MathPlayer in Internet Explorer is somewhat delicate, it is
controlled separately via ``showMathMenuMSIE``, but the latter is
now deprecated in favor of the MathJax contextual menu settings
for MathPlayer (see below).
If ``showMathMenu`` is ``true``, then right-clicking (on Windows
or Linux) or control-clicking (on Mac OS X) will produce a MathJax
menu that allows you to get the source of the mathematics in
various formats, change the size of the mathematics relative to
the surrounding text, get information about MathJax, and configure
other MathJax settings.
Set this to ``false`` to disable the menu. When ``true``, the
``MathMenu`` configuration block determines the operation of the
menu. See :ref:`the MathMenu options <configure-MathMenu>` for
more details.
These values used to be listed in the separate output jax, but
have been moved to this more central location since they are
shared by all output jax. MathJax will still honor their values
from their original positions, if they are set there.
.. describe:: menuSettings: { ... }
This block contains settings for the mathematics contextual menu
that act as the defaults for the user's settings in that menu.
The possible values are:
.. describe:: zoom: "None"
This indicates when typeset mathematics should be zoomed. It
can be set to ``"None"``, ``"Hover"``, ``"Click"``, or
``"Double-Click"`` to set the zoom trigger.
.. describe:: CTRL: false, ALT: false, CMD: false, Shift: false
These values indicate which keys must be pressed in order for
math zoom to be triggered. For example, if ``CTRL`` is set to
``true`` and ``zoom`` is ``"Click"``, then math will be zoomed
only when the user control-clicks on mathematics (i.e., clicks
while holding down the `CTRL` key). If more than one is
``true``, then all the indicated keys must be pressed for the
zoom to occur.
.. describe:: zscale: "200%"
This is the zoom scaling factor, and it can be set to any of
the values available in the `Zoom Factor` menu of the
`Settings` submenu of the contextual menu.
.. describe:: context: "MathJax"
This controls what contextual menu will be presented when a
right click (on a PC) or CTRL-click (on the Mac) occurs over a
typeset equation. When set to ``"MathJax"``, the MathJax
contextual menu will appear; when set to ``"Browser"``, the
browser's contextual menu will be used. For example, in
Internet Explorer with the MathPlayer plugin, if this is set
to ``"Browser"``, you will get the MathPlayer contextual menu
rather than the MathJax menu.
.. describe:: texHints: true
This controls whether the "Show Source" menu item includes
special class names that help MathJax to typeset the
mathematics that was produced by the TeX input jax. If these
are included, then you can take the output from "Show Source"
and put it into a page that uses MathJax's MathML input jax
and expect to get the same results as the original TeX.
(Without this, there may be some spacing differences.)
There are also settings for ``format``, ``renderer``, ``font``,
``mpContext``, and ``mpMouse``, but these are maintained by
MathJax and should not be set by the page author.
.. describe:: errorSettings: { ... }
This block contains settings that control how MathJax responds to
unexpected errors while processing mathematical equations. Rather
than simply crash, MathJax can report an error and go on. The
options you can set include:
.. describe:: message: ["[Math Processing Error]"]
This is an HTML snippet that will be inserted at the location
of the mathematics for any formula that causes MathJax to
produce an internal error (i.e., an error in the MathJax code
itself). See the :ref:`description of HTML snippets
<html-snippets>` for details on how to represent HTML code in
this way.
.. describe:: style: {color:"#CC0000", "font-style":"italic"}
This is the CSS style description to use for the error
messages produced by internal MathJax errors. See the section
on :ref:`CSS style objects <css-style-objects>` for details on
how these are specified in JavaScript.
.. describe:: v1.0-compatible: true
This controls whether MathJax issues the warning about not having an
explicit configuration in the event that the `jax` array is empty
after configuration is complete. If you really intend that array to
be empty, set this flag to ``false``. Note that setting this to false
does **not** cause a default configuration file to be loaded.

95
docs/html/_sources/options/index.txt
View File

@ -1,95 +0,0 @@
.. _configuration:
*********************
Configuration Objects
*********************
The various components of MathJax, including its input and output
processors, its preprocessors, its extensions, and the MathJax core,
all can be configured through the ``config/default.js`` file, or via a
:meth:`MathJax.Hub.Config()` call (indeed, if you look closely, you
will see that ``config/default.js`` is itself one big call to
:meth:`MathJax.Hub.Config()`). Anything that is in
``config/default.js`` can be included in-line to configure MathJax.
The structure that you pass to :meth:`MathJax.Hub.Config()` is a
JavaScript object that includes `name:value` pairs giving the names of
parameters and their values, with pairs separated by commas. Be
careful not to include a comma after the last value, however, as some
browsers (namely Internet Explorer) will fail to process the
configuration if you do.
The MathJax components, like the TeX input processor, have their own
sections in the configuration object labeled by the component name,
and using an object as its value. That object is itself
a configuration object made up of `name:value` pairs that give the
configuration options for the component.
For example,
.. code-block:: javascript
MathJax.Hub.Config({
showProcessingMessages: false,
jax: ["input/TeX", "output/HTML-CSS"],
TeX: {
TagSide: "left",
Macros: {
RR: '{\\bf R}',
bold: ['{\\bf #1}',1]
}
}
});
is a configuration that includes two settings for the MathJax Hub (one
for `showProcessingMessages` and one for the `jax` array), and a
configuration object for the TeX input processor. The latter includes
a setting for the TeX input processor's `TagSide` option (to set tags
on the left rather than the right) and a setting for `Macros`, which
defines new TeX macros (in this case, two macros, one called ``\RR``
that produces a bold "R", and one called ``\bold`` that puts is
argument in bold face).
The ``config/default.js`` file is another example that shows nearly
all the configuration options for all of MathJax's components.
Configuration Options by Component
==================================
The individual options are explained in the following sections, which
are categorized by the component they affect.
.. toctree::
:maxdepth: 1
The core options <hub>
.. toctree::
:maxdepth: 1
The tex2jax preprocessor options <tex2jax>
The mml2jax preprocessor options <mml2jax>
The asciimath2jax preprocessor options <asciimath2jax>
The jsMath2jax preprocessor options <jsMath2jax>
.. toctree::
:maxdepth: 1
The TeX input processor options <TeX>
The MathML input processor options <MathML>
The AsciiMath input processor options <AsciiMath>
The HTML-CSS output processor options <HTML-CSS>
The NativeMML output processor options <NativeMML>
The SVG output processor options <SVG>
The MMLorHTML configuration options <MMLorHTML>
.. toctree::
:maxdepth: 1
The MathMenu options <MathMenu>
The MathZoom options <MathZoom>
The MathEvents options <MathEvents>
The FontWarnings options <FontWarnings>

47
docs/html/_sources/options/jsMath2jax.txt
View File

@ -1,47 +0,0 @@
.. _configure-jsMath2jax:
***************************
The jsMath2jax Preprocessor
***************************
The options below control the operation of the `jsMath2jax`
preprocessor that is run when you include ``"jsMath2jax.js"`` in the
`extensions` array of your configuration. They are listed with their
default values. To set any of these options, include a ``jsMath2jax``
section in your :meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
jsMath2jax: {
preview: "none"
}
});
would set the ``preview`` parameter to ``"none"``.
.. describe:: preview: "TeX"
This controls whether `jsMath2jax` inserts ``MathJax_Preview`` spans
to make a preview available, and what preview to use, when it
locates in-line or display mathematics in the page. The default
is ``"TeX"``, which means use the TeX code as the preview (which
will be visible until it is processed by MathJax). Set to
``"none"`` to prevent previews from being inserted (the math
will simply disappear until it is typeset). Set to an array
containing the description of an HTML snippet in order to use the
same preview for all equations on the page.
Examples:
.. code-block:: javascript
preview: ["[math]"], // insert the text "[math]" as the preview
.. code-block:: javascript
preview: [["img",{src: "/images/mypic.jpg"}]], // insert an image as the preview
See the :ref:`description of HTML snippets <html-snippets>` for
details on how to represent HTML code in this way.

48
docs/html/_sources/options/mml2jax.txt
View File

@ -1,48 +0,0 @@
.. _configure-mml2jax:
************************
The mml2jax Preprocessor
************************
The options below control the operation of the `mml2jax` preprocessor
that is run when you include ``"mml2jax.js"`` in the `extensions` array
of your configuration. They are listed with their default values. To
set any of these options, include a ``mml2jax`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
mml2jax: {
preview: "none"
}
});
would set the ``preview`` parameter to ``"none"``.
.. describe:: preview: "alttext"
This controls whether `mml2jax` inserts ``MathJax_Preview`` spans
to make a preview available, and what preview to use, when it
locates mathematics on the page. The default is ``"alttext"``,
which means use the ``<math>`` tag's ``alttext`` attribute as the
preview (visible until it is processed by MathJax), if the tag has
one. Set it to ``"none"`` to prevent the previews from being
inserted (the math will simply disappear until it is typeset).
Set it to an array containing the description of an HTML snippet
in order to use the same preview for all equations on the page.
Examples:
.. code-block:: javascript
preview: ["[math]"], // insert the text "[math]" as the preview
.. code-block:: javascript
preview: [["img",{src: "/images/mypic.jpg"}]], // insert an image as the preview
See the :ref:`description of HTML snippets <html-snippets>` for
details on how to represent HTML code in this way.

155
docs/html/_sources/options/tex2jax.txt
View File

@ -1,155 +0,0 @@
.. _configure-tex2jax:
************************
The tex2jax Preprocessor
************************
The options below control the operation of the `tex2jax` preprocessor
that is run when you include ``"tex2jax.js"`` in the `extensions` array
of your configuration. They are listed with their default values. To
set any of these options, include a ``tex2jax`` section in your
:meth:`MathJax.Hub.Config()` call. For example
.. code-block:: javascript
MathJax.Hub.Config({
tex2jax: {
inlineMath: [ ['$','$'], ['\\(','\\)'] ]
}
});
would set the ``inlineMath`` delimiters for the `tex2jax`
preprocessor.
.. describe:: inlineMath: [['\\\(','\\\)']]
Array of pairs of strings that are to be used as in-line math
delimiters. The first in each pair is the initial delimiter and
the second is the terminal delimiter. You can have as many pairs
as you want. For example,
.. code-block:: javascript
inlineMath: [ ['$','$'], ['\\(','\\)'] ]
would cause `tex2jax` to look for ``$...$`` and ``\(...\)`` as
delimiters for inline mathematics. (Note that the single dollar
signs are not enabled by default because they are used too
frequently in normal text, so if you want to use them for math
delimiters, you must specify them explicitly.)
Note that the delimiters can't look like HTML tags (i.e., can't
include the less-than sign), as these would be turned into tags by
the browser before MathJax has the chance to run. You can only
include text, not tags, as your math delimiters.
.. describe:: displayMath: [ ['$$','$$'], ['\\\[','\\\]'] ]
Array of pairs of strings that are to be used as delimiters for
displayed equations. The first in each pair is the initial
delimiter and the second is the terminal delimiter. You can have
as many pairs as you want.
Note that the delimiters can't look like HTML tags (i.e., can't
include the less-than sign), as these would be turned into tags by
the browser before MathJax has the chance to run. You can only
include text, not tags, as your math delimiters.
.. describe:: balanceBraces: true,
This value determines whether `tex2jax` requires braces to be
balanced within math delimiters (which allows for nested dollar
signs). Set to ``false`` to get pre-v2.0 compatibility. When
``true``,
.. code-block:: latex
$y = x^2 \hbox{ when $x > 2$}$.
will be properly handled as a single expression. When ``false``,
it would be interpreted as two searpate expressions, each with
improperly balanced braces.
.. describe:: processEscapes: false
When set to ``true``, you may use ``\$`` to represent a literal
dollar sign, rather than using it as a math delimiter. When
``false``, ``\$`` will not be altered, and the dollar sign may be
considered part of a math delimiter. Typically this is set to
``true`` if you enable the ``$ ... $`` in-line delimiters, so you
can type ``\$`` and `tex2jax` will convert it to a regular dollar
sign in the rendered document.
.. describe:: processEnvironments: true
When ``true``, `tex2jax` looks not only for the in-line and
display math delimiters, but also for LaTeX environments
(``\begin{something}...\end{something}``) and marks them for
processing by MathJax. When ``false``, LaTeX environments will
not be processed outside of math mode.
.. describe:: preview: "TeX"
This controls whether `tex2jax` inserts ``MathJax_Preview`` spans
to make a preview available, and what preview to use, when it
locates in-line or display mathematics in the page. The default
is ``"TeX"``, which means use the TeX code as the preview (which
will be visible until it is processed by MathJax). Set to
``"none"`` to prevent previews from being inserted (the math
will simply disappear until it is typeset). Set to an array
containing the description of an HTML snippet in order to use the
same preview for all equations on the page.
Examples:
.. code-block:: javascript
preview: ["[math]"], // insert the text "[math]" as the preview
.. code-block:: javascript
preview: [["img",{src: "/images/mypic.jpg"}]], // insert an image as the preview
See the :ref:`description of HTML snippets <html-snippets>` for
details on how to represent HTML code in this way.
.. describe:: skipTags: ["script","noscript","style","textarea","pre","code"]
This array lists the names of the tags whose contents should not
be processed by `tex2jax` (other than to look for ignore/process
classes as listed below). You can add to (or remove from) this
list to prevent MathJax from processing mathematics in specific
contexts.
.. describe:: ignoreClass: "tex2jax_ignore"
This is the class name used to mark elements whose contents should
not be processed by tex2jax (other than to look for the
``processClass`` pattern below). Note that this is a regular
expression, and so you need to be sure to quote any `regexp`
special characters. The pattern is inserted into one that
requires your pattern to match a complete word, so setting
``ignoreClass: "class2"`` would cause it to match an element with
``class="class1 class2 class3"`` but not ``class="myclass2"``.
Note that you can assign several classes by separating them by the
vertical line character (``|``). For instance, with
``ignoreClass: "class1|class2"`` any element assigned a class of
either ``class1`` or ``class2`` will be skipped.
.. describe:: processClass: "tex2jax_process"
This is the class name used to mark elements whose contents
*should* be processed by `tex2jax`. This is used to restart
processing within tags that have been marked as ignored via the
``ignoreClass`` or to cause a tag that appears in the ``skipTags``
list to be processed rather than skipped. Note that this is a
regular expression, and so you need to be sure to quote any
`regexp` special characters. The pattern is inserted into one
that requires your pattern to match a complete word, so setting
``processClass: "class2"`` would cause it to match an element with
``class="class1 class2 class3"`` but not ``class="myclass2"``.
Note that you can assign several classes by separating them by the
vertical line character (``|``). For instance, with
``processClass: "class1|class2"`` any element assigned a class of
either ``class1`` or ``class2`` will have its contents processed.

262
docs/html/_sources/output.txt
View File

@ -1,262 +0,0 @@
.. _output-formats:
**********************
MathJax Output Formats
**********************
Currently, MathJax can render math in three ways:
- Using HTML-with-CSS to lay out the mathematics,
- Using :term:`SVG` to lay out the mathematics, or
- Using a browser's native MathML support.
These are implemented by the `HTML-CSS`, `SVG` and `NativeMML` output
processors.
If you are using one of the combined configuration files, then this will
select one of these output processors for you. If the config file ends in
``_HTML``, then it is the HTML-CSS output processor, and if it ends in
``_SVG`` then the SVG output processor will be used. If it ends in
``_HTMLorMML``, then the NativeMML output processor will be chosen if the
browser supports it well enough, otherwise HTML-CSS output will be used.
If you are performing your own in-line or file-based configuration,
you select which one you want to use by including either
``"output/HTML-CSS"``, ``"output/SVG"``, or ``"output/NativeMML"`` in
the `jax` array of your MathJax configuration. For example
.. code-block:: javascript
jax: ["input/TeX","output/HTML-CSS"]
would specify TeX input and HTML-with-CSS output for the mathematics
in your document.
The **HTML-CSS output processor** produces high-quality output in all
major browsers, with results that are consistent across browsers and
operating systems. This is MathJax's primary output mode. Its major
advantage is its quality and consistency; its drawback is that it is
slower than the NativeMML mode at rendering the mathematics.
Historically, the performance in Internet Explorer (and IE8 in
particular) was quite poor, with the page getting slower and slower as
more math is processed. MathJax version 2.0 includes a number of
optimizations to improve the display performance in IE, and it is now
more comparable to other browsers. The HTML-CSS output uses web-based
fonts so that users don't have to have math fonts installed on their
computers, which introduces some printing issues in certain browsers.
The **SVG output processor** is new in MathJax version 2.0, and it
uses `Scalable Vector Graphics` to render the mathematics on the page.
SVG is supported in all the major browsers and most mobile devices;
note, however, that Internet Explorer prior to IE9 does not support
SVG, and IE9 only does in "IE9 standards mode", not its emulation
modes for earlier versions. The SVG output mode is high quality and
slightly faster than HTML-CSS, and it does not suffer from some of the
font-related issues that HTML-CSS does, so prints well in all
browsers. This format also works well in some ebook readers (e.g.,
iBooks). The disadvantages of this mode are the following: first,
Internet Explorer only supports SVG in IE9 and later versions (and
then only in IE9 standards mode or above), and some versions of the
Android Internet browser don't have SVG enabled. Second, it does not
take advantage of STIX fonts, and so only has access to the characters
in the web-based fonts, and third, its variable-width tables become
fixed size once they are typeset, and don't rescale if the window size
changes (for example). Since equation numbers are handled through
variable-width tables, that means equation numbers may not stay at the
edge of the window if it is resized. For these reasons it is probably
best not to force the use of SVG output unless you have some control
over the browsers that are used to view your documents.
The **NativeMML output processor** uses the browser's internal MathML
support (if any) to render the mathematics. Currently, Firefox has
native support for MathML, and IE has the `MathPlayer plugin
<http://www.dessci.com/en/products/mathplayer/>`_ for rendering
MathML. Opera has some built-in support for MathML that works well
with simple equations, but fails with more complex formulas, so we
don't recommend using the NativeMML output processor with Opera.
Safari has some support for MathML since version 5.1, but the quality
is not as high as either Firefox's implementation or IE with MathPlayer.
Chrome, Konqueror, and most other browsers don't support MathML
natively, but this may change in the future, since MathML is part of
the HTML5 specification.
The advantage of the NativeMML output Processor is its speed, since
native MathML support is much faster than using complicated HTML and
CSS to typeset mathematics, as the HTML-CSS output processor does.
The disadvantage is that you are dependent on the browser's MathML
implementation for your rendering, and these vary in quality of output
and completeness of implementation. MathJax relies on features that
are not available in some renderers (for example, Firefox's MathML
support does not implement the features needed for labeled equations).
The results using the NativeMML output processor may have spacing or
other rendering problems that are outside of MathJax's control.
Automatic Selection of the Output Processor
===========================================
Since not all browsers support MathML natively, it would be unwise to
choose the NativeMML output processor unless you are sure of your
audience's browser capabilities. MathJax can help with that, however,
since a number of its combined configuration files will select
NativeMML output when the browser supports it well enough, and
HTML-CSS output otherwise. These are the configuration files that end
in ``_HTMLorMML``.
If you are doing your own configuration, there is a special configuration
file that you can include that will choose between NativeMML and HTML-CSS
depending on the browser in use. To invoke it, add ``"MMLorHTML.js"`` to
your configuration's `config` array, and **do not** include an output
processor in your `jax` array; MathJax will fill that in for you based on
the abilities of your user's browser.
.. code-block:: javascript
config: ["MMLorHTML.js"],
jax: ["input/TeX"]
By default, MathJax will choose HTML-CSS in all browsers except for
one case: Internet Explorer when the MathPlayer plugin is present.
In the past, MathJax selected NativeMML output for Firefox as well,
but we have found that there are too many rendering issues with
Firefox's native MathML implementation, and so MathJax now selects
HTML-CSS output for Firefox by default as well. Users can still use
the Mathjax contextual menu to select the NativeMML renderer if they
wish to choose greater speed at the expense of some quality.
You can customize which choice MathJax makes on a browser-by-browser
basis or a global basis. See the ``config/default.js`` file or the
:ref:`Configuring MMLorHTML <configure-MMLorHTML>` section for further
details. As an example, this configuration tells MathJax to use
native MathML support rather than HTML-CSS output for Firefox:
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
MMLorHTML: { prefer: { Firefox: "MML" } }
});
</script>
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
With this configuration, MathML output will be used for both Firefox
and IE with the MathPlayer plugin. Note, however, that a user can
employ the MathJax contextual menu to select the other renderer if he
or she wishes.
MathJax produces MathML that models the underlying mathematics as best
it can, rather than using complicated hacks to improve output for a
particular MathML implementation. When you make the choice to use the
NativeMML output processor, you are making a trade-off: gaining speed
at the expense of quality and reliability, a decision that should not
be taken lightly.
.. _automatic-linebreaking:
Automatic Line Breaking
=======================
The HTML-CSS and SVG output processors implement (most of) the MathML3
automatic line-breaking specification. (The NativeMML output
processor relies on the browser's native MathML support to handle line
breaking when it is used.) Since line-breaking takes extra processing
and so can slow down the mathematical output, it is off by default,
but you can enable it by adding
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
"HTML-CSS": { linebreaks: { automatic: true } },
SVG: { linebreaks: { automatic: true } }
});
</script>
to your page just before the ``<script>`` tag that loads
``MathJax.js`` itself.
Note that line breaking only applies to displayed equations, not
in-line equations (unless the in-line euqation is itself longer than a
line), and that the line-breaks are only computed once when the
equation is initially typeset, and do not change if the user changes
the window size, or if the container changes size for some other
reason.
You can control what width is used to determine where the line breaks
shoud occur using the ``container`` parameter of the ``linebreaks``
block. By default it is the width of the containing element, but you
can make it a fixed width, or make it a percentage of the container.
See the :ref:`HTML-CSS configuration <configure-HTML-CSS>` or
:ref:`SVG configuration <configure-SVG>` pages for more details.
The linbe-breaking algorithm uses the nesting depth, the type of
operator, the size of spaces, and other factors to decide on the
breakpoints, but it does not know the meaning of the mathematics, and
may not choose the optimal breakpoints. We will continue to work on
the algorithm as we gain information from its actual use in the field.
If you are using :term:`MathML` as your input format, you can use the
``linebreak="goodbreak"`` and ``linebreak="badbreak"`` attributes on
``<mo>`` elements to help MathJax pick the best breakpoints for your
mathematics.
.. _html-css-with-ie8:
HTML-CSS with IE
================
The performance of MathJax in Internet Explorer 8 and 9 has been
substantially improved in version 2.0. The HTML-CSS output processing
was redesigned to avoid the page reflows that were the main source of
the speed problem in I8 and IE9. For test pages having between 20 and
50 typeset expressions, we see an 80% reduction in output processing
time for IE8, a 50% reduction for IE9, and between 15% and 25%
reduction for most other browsers over the v1.1a times. Since the
processing time in v1.1a grows non-linearly in IE, you should see even
larger savings for pages with more equations when using v2.0.
In the past, we recommended forcing IE8 and IE9 into IE7-emulation
mode in order to get better performance. That is no longer necessary.
Indeed, the fastest modes in IE8 and IE9 now are their IE8 standards
and IE9 standards modes, so it is best to force the highest mode
possible. That can be accomplished by adding
.. code-block:: html
<meta http-equiv="X-UA-Compatible" content="IE=edge">
at the top of the ``<head>`` section of your HTML documents. Note
that this line must come at the beginning of the ``<head>``, before
any stylesheets, scripts, or other content are loaded.
.. _html-css-extensions:
HTML-CSS Extensions
===================
The HTML-CSS output jax uses elements with width set to 100% when it
typesets displayed equations. If there are floating elements on the
left or right, this can mean that displayed mathematics isn't properly
centered, and can cause equation numbers to overlap the floating
content. To avoid this, you can specify the `handle-floats` extension
in the `extensions` array of your `HTML-CSS` configuration block.
.. code-block:: javascript
"HTML-CSS": {
extensions: ["handle-floats.js"]
}
This will use CSS that puts the displayed equations into elements that
work like tabel cells, and won't overlap the floaring content.
Because this is somewhat of a misuse of CSS, it is not used by
default, but it has proved successful in most situations, so you may
consider using it in pages that include material that floats to the
left or right of text containing displayed mathematics, especially
when equation numbers or tags are used.
See the :ref:`HTML-CSS configuration options <configure-HTML-CSS>` for
other options of the HTML-CSS output jax.

79
docs/html/_sources/platforms/index.txt
View File

@ -1,79 +0,0 @@
.. _platforms:
======================================
Using MathJax in popular web platforms
======================================
MathJax plugins are available for a growing number of wikis, blogs,
and other content-management systems. These include WordPress,
Blogger, Sphinx, TiddlyWiki, and MathEL-Wiki. A list of these is
available in the `web applications
<http://www.mathjax.org/community/mathjax-in-use>`_ list of the
`MathJax web site <http://www.mathjax.org>`_.
If the program you are using is not one of these, you may still be able to
use MathJax by modifying the theme or template for your wiki or blog,
as explained below.
Using MathJax in a Theme File
=============================
Most web-based content-management systems include a theme or template
layer that determines how the pages look, and that loads information
common to all pages. Such theme files provide one popular way to
include MathJax in your web templates in the absence of
MathJax-specific plugins for the system you are using. To take
advantage of this approach, you will need access to your theme files,
which probably means you need to be an administrator for the site; if
you are not, you may need to have an administrator do these steps for
you.
To enable MathJax in your web platform, add the line::
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
either just before the ``</head>`` tag in your theme file, or at the end of
the file if it contains no ``</head>``.
The theme files for various popular platforms are:
`WordPress <http://wordpress.org/>`_
``wp-content/themes/[current_theme]/header.php``
`Movable Type <http://www.movabletype.org/>`_
``[current_theme_templates]/html_head.mhtml``
`Drupal <http://drupal.org/>`_
``themes/[current_theme]/page.tpl.php``
`Joomla <http://www.joomla.org/>`_
``templates/[current_theme]/index.php``
`MediaWiki <http://www.mediawiki.org/>`_
``skins/[current_skin].php``
`TiddlyWiki <http://www.tiddlywiki.com/>`_
``*.php`` (Whatever you call your TiddlyWiki php file)
`Moodle <http://moodle.org/>`_
``theme/[current_theme]/header.html``
Keep in mind that this will enable MathJax for your current
theme/template only. If you change themes or update your theme, you
will have to repeat these steps.
Instructions for Specific Platforms
===================================
Some programs, such as WordPress and Moveable Type, allow you to edit
template files from inside their administrator interfaces. Specific
instructions for these are given via the links below.
.. toctree::
:maxdepth: 1
Wordpress <wordpress>
Movable Type <movable-type>

38
docs/html/_sources/platforms/movable-type.txt
View File

@ -1,38 +0,0 @@
.. _platform-movable-type:
=============================
Using MathJax in Movable Type
=============================
1. Open Moveable Type Admin interface for the site on which you want to enable
MathJax.
2. In the dashboard menu on the left, open up the Design menu. This
should show you the templates you are currently using on the site.
.. image:: ../images/mt_menu.png
3. Scroll down to the Template Modules section in the template list
and open the `HTML Head` template.
.. image:: ../images/mt_templates.png
4. At the end of the file, insert
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
to load MathJax from our distributed network service.
.. image:: ../images/mt_head.png
5. Save the file. This will enable MathJax with both TeX and MathML
input, so you should be able to start adding mathematical content to
your pages. If you need to adjust the configuration, see
:ref:`Configuring MathJax <loading>` for more details.

42
docs/html/_sources/platforms/wordpress.txt
View File

@ -1,42 +0,0 @@
.. _platform-wordpress:
===============================
Installing MathJax in WordPress
===============================
Note that there is a `WordPress plugin for MathJax
<http://wordpress.org/extend/plugins/mathjax-latex/>`_, so that may be a
better choice than editing the theme directly.
1. Open the WordPress admin interface.
2. In the administration menu on the left, open up the `Appearance`
menu and click on the `Editor` submenu option.
.. image:: ../images/wp_menu.png
When you click on the editor option, WordPress should open up the
first stylesheet in the current theme.
3. In the template list on the right side of the page, click on the
header file (it should be ``header.php``).
.. image:: ../images/wp_templates.png
This part depends slightly on how your current theme is written.
In the ``header.php`` file, look for the end-of-head tag,
``</head>``. If you find it, insert
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
just before that. Otherwise, insert the same code at the very
bottom of the file.
4. Save the file. This will enable MathJax with both TeX and MathML
input, so you should be able to start adding mathematical content to
your pages. If you need to adjust the configuration, see
:ref:`Configuring MathJax <loading>` for more details.

254
docs/html/_sources/queues.txt
View File

@ -1,254 +0,0 @@
.. _using-queues:
************
Using Queues
************
The `callback queue` is one of MathJax's main tools for synchronizing
its actions, both internally, and with external programs, like
javascript code that you may write as part of dynamic web pages.
Because many actions in MathJax (like loading files) operate
asynchronously, MathJax needs a way to coordinate those actions so
that they occur in the right order. The
`MathJax.Callback.Queue` object provides that mechanism.
A `callback queue` is a list of commands that will be performed one at
a time, in order. If the return value of one of the commands is a
`Callback` object, processing is suspended until that callback is
called, and then processing of the commands is resumed. In this way,
if a command starts an asynchronous operation like loading a file, it
can return the callback for that file-load operation and the queue
will wait until the file has loaded before continuing. Thus a queue
can be used to guarantee that commands don't get performed until other
ones are known to be finished, even if those commands usually operate
asynchronously.
Constructing Queues
===================
A queue is created via the :meth:`MathJax.Callback.Queue()` command,
which returns a `MathJax.Callback.Queue` object. The queue
itself consists of a series of commands given as callback
specifications (see :ref:`Using Callbacks <using-callbacks>` for
details on callbacks), which allow you to provide functions (together
with their arguments) to be executed. You can provide the collection
of callback specifications when the queue is created by passing them
as arguments to :meth:`MathJax.Callback.Queue()`, or you can create an
empty queue to which commands are added later. Once a
`MathJax.Callback.Queue` object is created, you can push
additional callbacks on the end of the queue; if the queue is empty,
the command will be performed immediately, while if the queue is
waiting for another command to complete, the new command will be
queued for later processing.
For example,
.. code-block:: javascript
function f(x) {alert(x)}
var queue = MathJax.Callback.Queue([f, 15], [f, 10], [f, 5]);
queue.Push([f, 0]);
would create a queue containing three commands, each calling the
function ``f`` with a different input, that are performed in order. A
fourth command is then added to the queue, to be performed after the
other three. In this case, the result will be four alerts, the first
with the number 15, the second with 10, the third with 5 and the
fourth with 0. Of course ``f`` is not a function that operates
asynchronously, so it would have been easier to just call ``f`` four
times directly. The power of the queue comes from calling commands
that could operate asynchronously. For example:
.. code-block:: javascript
function f(x) {alert(x)}
MathJax.Callback.Queue(
[f, 1],
["Require", MathJax.Ajax, "[MathJax]/extensions/AMSmath.js"],
[f, 2]
);
Here, the command ``MathJax.Ajax.Require("[MathJax]/extensions/AMSmath.js")``
is queued between two calls to ``f``. The first call to ``f(1)`` will
be made immediately, then the :meth:`MathJax.Ajax.Require` statement
will be performed. Since the ``Require`` method loads a file, it
operates asynchronously, and its return value is a `MathJax.Callback`
object that will be called when the file is loaded. The call to
``f(2)`` will not be made until that callback is performed,
effectively synchronizing the second call to ``f`` with the completion
of the file loading. This is equivalent to
.. code-block:: javascript
f(1);
MathJax.Ajax.Require("[MathJax]/extensions/AMSmath.js", [f, 2]);
since the ``Require()`` command allows you to specify a (single)
callback to be performed on the completion of the file load. Note,
however, that the queue could be used to synchronize several file
loads along with multiple function calls, so is more flexible.
For example,
.. code-block:: javascript
MathJax.Callback.Queue(
["Require", MathJax.Ajax, "[MathJax]/extensions/AMSmath.js"],
[f, 1],
["Require", MathJax.Ajax, "[MathJax]/config/local/AMSmathAdditions.js"],
[f, 2]
);
would load the AMSmath extension, then call ``f(1)`` then load the
local AMSmath modifications, and then call ``f(2)``, with each action
waiting for the previous one to complete before being performed
itself.
Callbacks versus Callback Specifications
========================================
If one of the callback specifications is an actual callback object
itself, then the queue will wait for that action to be performed
before proceeding. For example,
.. code-block:: javascript
MathJax.Callback.Queue(
[f, 1],
MathJax.Ajax.Require("[MathJax]/extensions/AMSmath.js"),
[f, 2],
);
starts the loading of the AMSmath extension before the queue is
created, and then creates the queue containing the call to ``f``, the
callback for the file load, and the second call to ``f``. The queue
performs ``f(1)``, waits for the file load callback to be called, and
then calls ``f(2)``. The difference between this and the second
example above is that, in this example the file load is started before
the queue is even created, so the file is potentially loaded and
executed before the call to ``f(1)``, while in the example above, the
file load is guaranteed not to begin until after ``f(1)`` is executed.
As a further example, consider
.. code-block:: javascript
MathJax.Callback.Queue(
MathJax.Ajax.Require("[MathJax]/extensions/AMSmath.js"),
[f, 1],
MathJax.Ajax.Require("[MathJax]/config/local/AMSmathAdditions.js"),
[f, 2]
);
in comparison to the example above that uses ``["Require",
MathJax.Ajax, "[MathJax]/extensions/AMSmath.js"]`` and ``["Require",
MathJax.Ajax, "[MathJax]/config/local/AMSmathAdditions.js"]`` instead. In that
example, ``AMSmath.js`` is loaded, then ``f(1)`` is called, then the
local additions are loaded, then ``f(2)`` is called.
Here, however, both file loads are started before the queue is
created, and are operating in parallel (rather than sequentially as in
the earlier example). It is possible for the loading of the local
additions to complete before the AMSmath extension is loaded in this
case, which was guaranteed **not** to happen in the other example.
Note, however, that ``f(1)`` is guaranteed not to be performed until
after the AMSmath extensions load, and ``f(2)`` will not occur until
after both files are loaded.
In this way, it is possible to start asynchronous loading of several
files simultaneously, and wait until all of them are loaded (in
whatever order) to perform some command. For instance,
.. code-block:: javascript
MathJax.Callback.Queue(
MathJax.Ajax.Require("file1.js"),
MathJax.Ajax.Require("file2.js"),
MathJax.Ajax.Require("file3.js"),
MathJax.Ajax.Require("file4.js"),
[f, "all done"]
);
starts four files loading all at once, and waits for all four to
complete before calling ``f("all done")``. The order in which they
complete is immaterial, and they all are being requested
simultaneously.
The MathJax Processing Queue
============================
MathJax uses a queue stored as ``MathJax.Hub.queue`` to regulate its
own actions so that they operate in the right order even when some
of them include asynchronous operations. You can take advantage of
that queue when you make calls to MathJax methods that need to be
synchronized with the other actions taken by MathJax. It may not
always be apparent, however, which methods fall into that category.
The main source of asynchronous actions in MathJax is the loading of
external files, so any action that may cause a file to be loaded may
act asynchronously. Many important actions do so, including some that
you might not expect; e.g., typesetting mathematics can cause files to
be loaded. This is because some TeX commands, for example, are rare
enough that they are not included in the core TeX input processor, but
instead are defined in extensions that are loaded automatically when
needed. The typesetting of an expression containing one of these TeX
commands can cause the typesetting process to be suspended while the
file is loaded, and then restarted when the extension has become
available.
As a result, any call to :meth:`MathJax.Hub.Typeset()` (or
:meth:`MathJax.Hub.Process()`, or :meth:`MathJax.Hub.Update()`, etc.)
could return long before the mathematics is actually typeset, and the
rest of your code may run before the mathematics is available. If you
have code that relies on the mathematics being visible on screen, you
will need to break that out into a separate operation that is
synchronized with the typesetting via the MathJax queue.
Furthermore, your own typesetting calls may need to wait for file loading
to occur that is already underway, so even if you don't need to access
the mathematics after it is typeset, you may still need to queue the
typeset command in order to make sure it is properly synchronized with
*previous* typeset calls. For instance, if an earlier call
started loading an extension and you start another typeset call before
that extension is fully loaded, MathJax's internal state may be in
flux, and it may not be prepared to handle another typeset operation
yet. This is even more important if you are using other libraries
that may call MathJax, in which case your code may not be aware of the
state that MathJax is in.
For these reasons, it is always best to perform typesetting operations
through the MathJax queue, and the same goes for any other action
that could cause files to load. A good rule of thumb is that, if a
MathJax function includes a callback argument, that function may operate
asynchronously; you should use the MathJax queue to perform it and
any actions that rely on its results.
To place an action in the MathJax queue, use the
:meth:`MathJax.Hub.Queue()` command. For example
.. code-block:: javascript
MathJax.Hub.Queue(["Typeset",MathJax.Hub,"MathDiv"]);
would queue the command ``MathJax.Hub.Typeset("MathDiv")``, causing
the contents of the DOM element with `id` equal to ``MathDiv`` to be
typeset.
One of the uses of the MathJax queue is to allow you to synchronize an
action with the startup process for MathJax. If you want to have a
function performed after MathJax has become completely set up (and
performed its initial typesetting of the page), you can push it onto
the ``MathJax.Hub.queue`` so that it won't be performed until MathJax
finishes everything it has queued when it was loaded. For example,
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js"></script>
<script>
MathJax.Hub.Queue(function () {
// ... your startup commands here ...
});
</script>

164
docs/html/_sources/signals.txt
View File

@ -1,164 +0,0 @@
.. _using-signals:
*************
Using Signals
*************
Because much of MathJax operates asynchronously, it is important for
MathJax to be able to indicate to other components operating on the
page that certain actions have been taken. For example, as MathJax is
starting up, it loads external files such as its configuration files
and the various input and output :term:`jax` that are used on the
page. This means that MathJax may not be ready to run until well
after the ``<script>`` tag that loads ``MathJax.js`` has executed. If
another component on the page needs to call MathJax to process some
mathematics, it will need to know when MathJax is ready to do that.
Thus MathJax needs a way to signal other components that it is
initialized and ready to process mathematics. Other events that might
need to be signaled include the appearance of newly processed
mathematics on the web page, the loading of a new extension, and so
on.
The mechanism provided by MathJax for handling this type of
communication is the :term:`Callback Signal`. The `Callback Signal`
object provides a standardized mechanism for sending and receiving
messages between MathJax and other code on the page. A signal acts
like a mailbox where MathJax places messages for others to read.
Those interested in seeing the messages can register an interest in
receiving a given signal, and when MathJax posts a message on that
signal, all the interested parties will be notified. No new posts to
the signal will be allowed until everyone who is listening to the
signal has had a chance to receive the first one. If a signal causes
a listener to begin an asynchronous operation (such as loading a
file), the listener can indicate that its reply to the signal is going
to be delayed, and MathJax will wait until the asynchronous action is
complete before allowing additional messages to be posted to this
signal. In this way, posting a signal may itself be an asynchronous
action.
The posts to a signal are cached so that if a new listener expresses
an interest in the signal, it will receive all the past posts as well
as any future ones. For example, if a component on the page needs to
know when MathJax is set up, it can express an interest in the startup
signal's ``End`` message. If MathJax is not yet set up, the component
will be signaled when MathJax is ready to begin, but if MathJax is
already set up, the component will receive the ``End`` message
immediately, since that message was cached and is available to any new
listeners. In this way, signals can be used to pass messages without
worrying about the timing of when the signaler and listener are ready
to send or receive signals: a listener will receive messages even if
it starts listening after they were sent.
One way that MathJax makes use of this feature is in configuring its
various extensions. The extension may not be loaded when the user's
configuration code runs, so the configuration code can't modify the
extension because it isn't there yet. Fortunately, most extensions
signal when they are loaded and initialized via an ``Extension [name]
Ready`` message, or just ``[name] Ready``, so the configuration code
can implement a listener for that message, and have the listener
perform the configuration when the message arrives. But even if the
extension *has* already been loaded, this will still work, because the
listener will receive the ready signal even if it has already been
posted. In this way, listening for signals is a robust method of
synchronizing code components no matter when they are loaded and run.
In some cases, it may be inappropriate for a new listener to receive
past messages that were sent to a signal object. There are two ways to
handle this: first, a new listener can indicate that it doesn't want
to hear old messages when it attaches itself to a signal object. The
sender can also indicate that past messages are not appropriate for
new listeners. It does this by clearing the message history so that
new listeners have no old posts to hear.
The actual message passed along by the signal can be anything, but is
frequently a string constant indicating the message value. It could
also be a JavaScript array containing data, or an object containing
`key:value` pairs. All the listeners receive the data as part of the
message, and can act on it in whatever ways they see fit.
Creating a Listener
===================
MathJax maintains two separate pre-defined signal channels: the
`startup signal` and the `processing signal` (or the `hub signal`).
The startup signal is where the messages about different components
starting up and becoming ready appear. The processing signal is where
the messages are sent about processing mathematics, like the ``New
Math`` messages for when newly typeset mathematics appears on the
page. The latter is cleared when a new processing pass is started (so
messages from past processing runs are not kept).
The easiest way to create a listener is to use either
:meth:`MathJax.Hub.Register.StartupHook()` or
:meth:`MathJax.Hub.Register.MessageHook()`. The first sets a listener
on the startup signal, and the latter on the hub processing signal.
You specify the message you want to listen for, and a callback to be
called when it arrives. For example
.. code-block:: javascript
MathJax.Hub.Register.StartupHook("TeX Jax Ready ",function () {
alert("The TeX input jax is loaded and ready!");
});
See the :ref:`MathJax Startup Sequence <startup-sequence>` page for
details of the messages sent during startup. See also the
`test/sample-signals.html
<http://cdn.mathjax.org/mathjax/latest/test/sample-signals.html>`_
file (and its source) for examples of using signals. This example
lists all the signals that occur while MathJax is processing that
page, so it gives useful information about the details of the signals
produced by various components.
In this example, the listener starts loading an extra configuration
file (from the same directory as the web page). Since it returns
the callback from that request, the signal processing will wait until
that file is completely loaded before it continues; that is, the
configuration process is suspended until the extra configuration file
has loaded.
.. code-block:: javascript
MathJax.Hub.Register.StartupHook("Begin Config",
function () {return MathJax.Ajax.Require("myConfig.js")}
);
Here is an example that produces an alert each time new mathematics
is typeset on the page. The message includes the DOM `id` of the
element on the page that contains the newly typeset mathematics as its
second element, so this listener locates the ``<script>`` tag
for the math, and displays the original source mathematics for it.
.. code-block:: javascript
MathJax.Hub.Register.MessageHook("New Math", function (message) {
var script = MathJax.Hub.getJaxFor(message[1]).SourceElement();
alert(message.join(" ")+": '"+script.text+"'");
})
Listening for All Messages
==========================
If you want to process *every* message that passes through a signal
channel, you can do that by registering an interest in the signal
rather than registering a message hook. You do this by calling the
signal's :meth:`Interest()` method, as in the following example.
.. code-block:: javascript
MathJax.Hub.Startup.signal.Interest(
function (message) {alert("Startup: "+message)}
);
MathJax.Hub.signal.Interest(
function (message) {alert("Hub: "+message)}
);
This will cause an alert for every signal that MathJax produces. You
probably don't want to try this out, since it will produce a *lot* of
them; instead, use the `test/sample-signals.html
<http://cdn.mathjax.org/mathjax/latest/test/sample-signals.html>`_
file, which displays them in the web page.
See the :ref:`Signal Object <api-signal>` reference page for details on the
structure and methods of the signal object.

510
docs/html/_sources/start.txt
View File

@ -1,510 +0,0 @@
.. _getting-started:
***************
Getting Started
***************
MathJax allows you to include mathematics in your web pages, either
using LaTeX, MathML, or AsciiMath notation, and the mathematics
will be processed using javascript to produce HTML, SVG or MathML
equations for viewing in any modern browser.
There are two ways to access MathJax: the easiest way is to use the
copy of MathJax available from our distributed network service at
``cdn.mathjax.org``, but you can also download and install a copy of
MathJax on your own server, or use it locally on your hard disk
(with no need for network access). All three of these are described
below, with links to more detailed explanations. This page gives the
quickest and easiest ways to get MathJax up and running on your web
site, but you may want to read the details in order to customize the
setup for your pages.
.. _mathjax-CDN:
Using the MathJax Content Delivery Network (CDN)
================================================
To use MathJax from our server, you need to do two things:
1. Link MathJax into the web pages that are to include mathematics.
2. Put mathematics into your web pages so that MathJax can display
it.
You accomplish the first step by putting
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
into the ``<head>`` block of your document. (It can also go in the
``<body>`` if necessary, but the head is to be preferred.) This will
load the latest version of MathJax from the distributed server, and
configure it to recognize mathematics in both TeX and MathML notation,
and ask it to generate its output using MathML if the browser supports
that well enough, and otherwise use HTML-with-CSS to display the
mathematics. This is one of the most general configurations, and
should suffice for most people's needs. Other configurations are
available, however, and you can also provide additional configuration
parameters to taylor one of the configurations to your needs. More
details can be found in the :ref:`Loading and Configuring MathJax
<loading>` instructions.
The use of ``cdn.mathjax.org`` is governed by its `terms of service
<http://www.mathjax.org/download/mathjax-cdn-terms-of-service/>`_, so be
sure to read that before linking to the MathJax CDN server.
To see how to enter mathematics in your web pages, see `Putting
mathematics in a web page`_ below.
Secure Access to the CDN
------------------------
When the the MathJax CDN is accessed via the address
``http://cdn.mathjax.org``, data is downloaded over a regular, insecure
HTTP connection. This introduces a security risk, since it is
possible a hostile 3rd party could intercept the MathJax program data,
and replace it. This is sometimes called a
`man-in-the-middle <http://en.wikipedia.org/wiki/Man-in-the-middle_attack>`_ attack.
To prevent such attacks, it is necessary to access the MathJax CDN
over a secure HTTPS connection. This can be done easily by using the
following ``<script>`` tag instead of the one listed above:
.. code-block:: html
<script type="text/javascript"
src="https://d3eoax9i5htok0.cloudfront.net/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
Currently, the Amazon Cloudfront service used by the MathJax CDN does
not support the use of a human-friendly name like ``cdn.mathjax.org``
for secure connections; however, the address given above is stable and
safe to use.
Installing Your Own Copy of MathJax
===================================
We recommend using the CDN service if you can, but you can also install
MathJax on your own server, or locally on your own hard disk. To do
so you will need to do the following things:
1. Obtain a copy of MathJax and make it available on your server or
hard disk.
2. Configure MathJax to suit the needs of your site.
3. Link MathJax into the web pages that are to include mathematics.
4. Put mathematics into your web pages so that MathJax can display
it.
Obtaining and Installing MathJax
--------------------------------
The easiest way to set up MathJax is to obtain the v2.0 archive from
the `MathJax download page <http://www.mathjax.org/download/>`_ (you
should obtain a file named something like
``mathjax-MathJax-v2.0-X-XXXXXXXX.zip`` where the X's are random
looking numbers and letters). This archive includes both the MathJax
code and the MathJax webfonts, so it is the only file you need. Note
that this is different from v1.0 and earlier releases, which had the
fonts separate from the rest of the code.
Unpack the archive and place the resulting MathJax folder onto your
web server at a convenient location where you can include it into your
web pages. For example, making ``MathJax`` a top-level directory on
your server would be one natural way to do this. That would let you
refer to the main MathJax file via the URL ``/MathJax/MathJax.js``
from within any page on your server.
**Note:** While this is the easiest way to set up MathJax initially, there
is a better way to do it if you want to be able to keep your copy of
MathJax up-to-date. That uses the `Git <http://git-scm.com/>`_ version
control system, and is described in the :ref:`Installing MathJax
<getting-mathjax-git>` document. If you prefer using `Subversion
<http://subversion.apache.org/>`_, you can also use that to get a copy
of MathJax (see :ref:`Installing MathJax via SVN
<getting-mathjax-svn>`).
Once you have MathJax set up on your server, you can test it using the
files in the ``MathJax/test`` directory. If you are putting MathJax
on a server, load them in your browser using their web addresses
rather than opening them locally (i.e., use an ``http://`` URL rather
than a ``file://`` URL). When you view the ``index.html`` file, after
a few moments you should see a message indicating that MathJax appears
to be working. If not, check that the files have been transferred to
the server completely and that the permissions allow the server to
access the files and folders that are part of the MathJax directory.
(Be sure to verify the MathJax folder's permissions as well.) Check
the server log files for any errors that pertain to the MathJax
installation; this may help locate problems in the permission or
locations of files.
Configuring your copy of MathJax
--------------------------------
When you include MathJax into your web pages as described below, it
will load the file ``config/TeX-AMS-MML_HTMLorMML.js`` (i.e., the file
named ``TeX-AMS-MML_HTMLorMML.js`` in the ``config`` folder of the
main ``MathJax`` folder). This file preloads all the most
commonly-used components of MathJax, allowing it to process
mathematics that is in the TeX or LaTeX format, or in MathML notation.
It will produce output in MathML form if the user's browser supports
that sufficiently, and will use HTML-with-CSS to render the
mathematics otherwise.
There are a number of other prebuilt configuration files that you can
choose from as well, or you could use the ``config/default.js`` file and
customize the settings yourself. The combined configuration files are
described more fully in :ref:`Common Configurations
<common-configurations>`, and the configuration options are described in
:ref:`Configuration Options <configuration>`.
Note: The configuration process changed between MathJax v1.0 and v1.1,
so if you have existing pages that use MathJax v1.0, you may need to
modify the tag that loads MathJax so that it conforms with the new
configuration process. See :ref:`Installing and Configuring MathJax
<installation>` for more details.
Linking your copy of MathJax into a web page
--------------------------------------------
You can include MathJax in your web page by putting
.. code-block:: html
<script type="text/javascript" src="path-to-MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
in your document's ``<head>`` block. Here, ``path-to-MathJax`` should
be replaced by the URL for the main MathJax directory, so if you have
put the ``MathJax`` directory at the top level of you server's web
site, you could use
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
to load MathJax in your page. For example, your page could look like
.. code-block:: html
<html>
<head>
...
<script type="text/javascript" src="/MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
</head>
<body>
...
</body>
</html>
If you have installed MathJax on a server that is in a different
domain from the one serving the page that loads MathJax, be sure to
read the :ref:`Notes About Shared Servers <cross-domain-linking>` for
more details. In that case, you may wish to consider using the
:ref:`MathJax CDN <mathjax-cdn>` rather than installing your own copy
of MathJax.
Putting mathematics in a web page
=================================
To put mathematics in your web page, you can use :term:`TeX` and
:term:`LaTeX` notation, :term:`MathML` notation, :term:`AsciiMath`
notation, or a combination of all three within the same page; the
MathJax configuration tells MathJax which you want to use, and how you
plan to indicate the mathematics when you are using TeX notation. The
configuration file used in the examples above tells MathJax to look
for both TeX and MathML notation within your pages. Other
configuration files tell MathJax to use AsciiMath input. These three
formats are described in more detail below.
.. _tex-and-latex-input:
TeX and LaTeX input
-------------------
Mathematics that is written in :term:`TeX` or :term:`LaTeX` format is
indicated using *math delimiters* that surround the mathematics,
telling MathJax what part of your page represents mathematics and what
is normal text. There are two types of equations: ones that occur
within a paragraph (in-line mathematics), and larger equations that
appear separated from the rest of the text on lines by themselves
(displayed mathematics).
The default math delimiters are ``$$...$$`` and ``\[...\]`` for
displayed mathematics, and ``\(...\)`` for in-line mathematics. Note
in particular that the ``$...$`` in-line delimiters are **not** used
by default. That is because dollar signs appear too often in
non-mathematical settings, which could cause some text to be treated
as mathematics unexpectedly. For example, with single-dollar
delimiters, "... the cost is $2.50 for the first one, and $2.00 for
each additional one ..." would cause the phrase "2.50 for the first
one, and" to be treated as mathematics since it falls between dollar
signs. For this reason, if you want to use single-dollars for in-line
math mode, you must enable that explicitly in your configuration:
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}
});
</script>
<script type="text/javascript" src="path-to-mathjax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
See the ``config/default.js`` file, or the :ref:`tex2jax configuration
options <configure-tex2jax>` page, for additional configuration
parameters that you can specify for the `tex2jax` preprocessor,
which is the component of MathJax that identifies TeX notation within
the page. See the :ref:`TeX and LaTeX <TeX-support>` page for
more on MathJax's support for TeX, and in particular how to deal with
single dollar signs in your text when you have enabled single
dollar-sign delimiters.
Here is a complete sample page containing TeX mathematics (also
available in the `test/sample-tex.html
<http://cdn.mathjax.org/mathjax/2.0-latest/test/sample-tex.html>`_
file):
.. code-block:: html
<!DOCTYPE html>
<html>
<head>
<title>MathJax TeX Test Page</title>
<script type="text/x-mathjax-config">
MathJax.Hub.Config({tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}});
</script>
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
</head>
<body>
When $a \ne 0$, there are two solutions to \(ax^2 + bx + c = 0\) and they are
$$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$
</body>
</html>
Since the TeX notation is part of the text of the page, there are some
caveats that you must keep in mind when you enter your mathematics.
In particular, you need to be careful about the use of less-than
signs, since those are what the browser uses to indicate the start of
a tag in HTML. Putting a space on both sides of the less-than sign
should be sufficient, but see :ref:`TeX and LaTeX support
<TeX-support>` for details.
If you are using MathJax within a blog, wiki, or other content
management system, the markup language used by that system may
interfere with the TeX notation used by MathJax. For example, if your
blog uses :term:`Markdown` notation for authoring your pages, the
underscores used by TeX to indicate subscripts may be confused with
the use of underscores by Markdown to indicate italics, and the two
uses may prevent your mathematics from being displayed. See :ref:`TeX
and LaTeX support <TeX-support>` for some suggestions about how to
deal with the problem.
There are a number of extensions for the TeX input processor that are
loaded by the ``TeX-AMS-MML_HTMLorMML`` configuration. These include:
- `TeX/AMSmath.js`, which defines the AMS math environments and
macros,
- `TeX/AMSsymbols.js`, which defines the macros for the symbols in
the `msam10` and `msbm10` fonts,
- `TeX/noErrors.js`, which shows the original TeX code rather than
an error message when there is a problem processing the TeX, and
- `TeX/noUndefined.js`, which prevents undefined macros from
producing an error message, and instead shows the macro name in red.
Other extensions may be loaded automatically when needed. See
:ref:`TeX and LaTeX support <TeX-support>` for details on the other
TeX extensions that are available.
.. _mathml-input:
MathML input
------------
For mathematics written in :term:`MathML` notation, you mark your
mathematics using standard ``<math>`` tags, where ``<math
display="block">`` represents displayed mathematics and ``<math
display="inline">`` or just ``<math>`` represents in-line mathematics.
Note that this will work in HTML files, not just XHTML files (MathJax
works with both), and that the web page need not be served with any
special MIME-type. Also note that, unless you are using XHTML rather
than HTML, you should not include a namespace prefix for your
``<math>`` tags; for example, you should not use ``<m:math>`` except
in a file where you have tied the ``m`` namespace to the MathML DTD by
adding the ``xmlns:m="http://www.w3.org/1998/Math/MathML"`` attribtue
to your file's ``<html>`` tag.
Although it is not required, it is recommended that you include the
``xmlns="http://www.w3.org/1998/Math/MathML"`` attribute on all
``<math>`` tags in your document (and this is preferred to the use of
a namespace prefix like ``m:`` above, since those are deprecated in
HTML5) in order to make your MathML work in the widest range of
situations.
Here is a complete sample page containing MathML mathematics (also
available in the `test/sample-mml.html
<http://cdn.mathjax.org/mathjax/2.0-latest/test/sample-mml.html>`_
file):
.. code-block:: html
<!DOCTYPE html>
<html>
<head>
<title>MathJax MathML Test Page</title>
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
</head>
<body>
<p>
When
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>a</mi><mo>&#x2260;</mo><mn>0</mn>
</math>,
there are two solutions to
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>a</mi><msup><mi>x</mi><mn>2</mn></msup>
<mo>+</mo> <mi>b</mi><mi>x</mi>
<mo>+</mo> <mi>c</mi> <mo>=</mo> <mn>0</mn>
</math>
and they are
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
<mi>x</mi> <mo>=</mo>
<mrow>
<mfrac>
<mrow>
<mo>&#x2212;</mo>
<mi>b</mi>
<mo>&#x00B1;</mo>
<msqrt>
<msup><mi>b</mi><mn>2</mn></msup>
<mo>&#x2212;</mo>
<mn>4</mn><mi>a</mi><mi>c</mi>
</msqrt>
</mrow>
<mrow> <mn>2</mn><mi>a</mi> </mrow>
</mfrac>
</mrow>
<mtext>.</mtext>
</math>
</p>
</body>
</html>
When entering MathML notation in an HTML page (rather than an XHTML
page), you should **not** use self-closing tags, but should use explicit
open and close tags for all your math elements. For example, you
should use
.. code-block:: html
<mspace width="5pt"></mspace>
rather than ``<mspace width="5pt" />`` in an HTML document. If you
use the self-closing form, some browsers will not build the math tree
properly, and MathJax will receive a damaged math structure, which
will not be rendered as the original notation would have been.
Typically, this will cause parts of your expression to not be
displayed. Unfortunately, there is nothing MathJax can do about that,
since the browser has incorrectly interpreted the tags long before
MathJax has a chance to work with them.
The component of MathJax that recognizes MathML notation within the
page is called the `mml2jax` extension, and it has only a few
configuration options; see the ``config/default.js`` file or the
:ref:`mml2jax configuration options <configure-mml2jax>` page for more
details. See the :ref:`MathML <MathML-support>` page for more on
MathJax's MathML support.
.. _asciimath-input:
AsciiMath input
---------------
MathJax v2.0 includes a new input format: :term:`AsciiMath` notation.
For mathematics written in this form, you mark your mathematical
expressions by surrounding them in "back-ticks", i.e., ```...```.
Here is a complete sample page containing AsciiMath notation (also
available in the `test/sample-asciimath.html
<http://cdn.mathjax.org/mathjax/2.0-latest/test/sample-asciimath.html>`_
file):
.. code-block:: html
<!DOCTYPE html>
<html>
<head>
<title>MathJax AsciiMath Test Page</title>
<script type="text/javascript"
src="../MathJax.js?config=AM_HTMLorMML-full"></script>
</head>
<body>
<p>When `a != 0`, there are two solutions to `ax^2 + bx + c = 0` and
they are</p>
<p style="text-align:center">
`x = (-b +- sqrt(b^2-4ac))/(2a) .`
</p>
</body>
</html>
The component of MathJax that recognizes asciimath notation within the
page is called the `asciimath2jax` extension, and it has only a few
configuration options; see the ``config/default.js`` file or the
:ref:`asciimath2jax configuration options <configure-asciimath2jax>` page for more
details. See the :ref:`AsciiMath support <AsciiMath-support>` page for more on
MathJax's AsciiMath support.
Where to go from here?
======================
If you have followed the instructions above, you should now have
MathJax installed and configured on your web server, and you should be
able to use it to write web pages that include mathematics. At this
point, you can start making pages that contain mathematical content!
You could also read more about the details of how to :ref:`customize
MathJax <loading>`.
If you are trying to use MathJax in blog or wiki software or in some
other content-management system, you might want to read about :ref:`using
MathJax in popular platforms <platforms>`.
If you are working on dynamic pages that include mathematics, you
might want to read about the :ref:`MathJax Application Programming
Interface <mathjax-api>` (its API), so you know how to include
mathematics in your interactive pages.
If you are having trouble getting MathJax to work, you can read more
about :ref:`installing MathJax <installation>`, or :ref:`loading and
configuring MathJax <loading>`.
Finally, if you have questions or comments, or want to help support
MathJax, you could visit the :ref:`MathJax community forums
<community-forums>` or the :ref:`MathJax bug tracker
<community-tracker>`.

186
docs/html/_sources/startup.txt
View File

@ -1,186 +0,0 @@
.. _startup-sequence:
****************************
The MathJax Startup Sequence
****************************
When you load ``MathJax.js`` into a web page, it configures itself and
immediately begins loading the components it needs. As MathJax starts
up, it uses its :ref:`signaling mechanism <synchronization>`
to indicate the actions that it is taking so that MathJax extensions
can tie into the initialization process, and so other applications
within the page can synchronize their actions with MathJax.
The startup process performs the following actions:
- It creates the ``MathJax`` variable, and defines the following
subsystems:
- ``MathJax.Object`` (object-oriented programming model)
- ``MathJax.Callback`` (callbacks, signals, and queues)
- ``MathJax.Ajax`` (file-loading and style-creation code)
- ``MathJax.HTML`` (support code for creating HTML elements)
- ``MathJax.Message`` (manages the menu line in the lower left)
- ``MathJax.Hub`` (the core MathJax functions)
..
- It then creates the base ``MathJax.InputJax``,
``MathJax.OutputJax``, and ``MathJax.ElementJax`` objects.
..
- MathJax sets up the default configuration, and creates the
signal objects used for the startup and hub actions.
..
- MathJax locates the ``<script>`` tag that loaded the ``MathJax.js``
file, and sets the ``MathJax.Hub.config.root`` value to reflect the
location of the MathJax root directory.
..
- MathJax determines the browser being used and its version. It sets
up the ``MathJax.Hub.Browser`` object, which includes the browser
name and version, plus ``isMac``, ``isPC``, ``isMSIE``, and so on.
..
- MathJax set up the ``MathJax.Hub.queue`` command queue, and
populates it with the commands MathJax runs at startup. This
includes creating the ``MathJax.Hub.Startup.onload`` onload
handler that is used to synchronize MathJax's action with the
loading of the page.
Once the ``MathJax.Hub.queue`` is created, the following actions are
pushed into the queue:
1. Post the ``Begin`` startup signal
..
2. Perform the configuration actions:
- Post the ``Begin Config`` startup signal
- Load any configuration files specified via ``config=`` as a script parameter
- Execute the content of the ``<script>`` that loaded MathJax, if it is not empty
- Wait for the ``delayStartupUntil`` condition to be met, if one was specified
- Execute any ``text/x-mathjax-config`` script blocks
- load the files listed in the ``MathJax.Hub.config.config`` array
- Post the ``End Config`` startup signal
..
3. Load the cookie values:
- Post the ``Begin Cookie`` startup signal
- Load the menu cookie values
- Use the cookie to set the renderer, if it is set
- Post the ``End Cookie`` startup signal
..
4. Define the MathJax styles:
- Post the ``Begin Styles`` startup signal
- Load the stylesheet files from the ``MathJax.Hub.config.stylesheets`` array
- Define the stylesheet described in ``MathJax.Hub.config.styles``
- Post the ``End Styles`` startup signal
..
5. Initialize the Message system (the grey information box in the
lower left)
..
6. Load the jax configuration files:
- Post the ``Begin Jax`` startup signal
- Load the jax config files from the ``MathJax.Hub.config.jax`` array
- The jax will register themselves when they are loaded
- Post the ``End Jax`` startup signal
..
7. Load the extension files:
- Post the ``Begin Extensions`` startup signal
- Load the files from the ``MathJax.Hub.config.extensions`` array
- Most extensions will post a ``[name] Ready`` or ``Extension
[name] Ready`` startup message when they are loaded (where
``[name]`` is the name of the extension)
- Post the ``End Extensions`` startup signal
..
8. Set the MathJax menu's renderer value based on the jax that have been
loaded
..
9. Wait for the onload handler to fire (in MathJax v2.0 this can
occur on the ``DOMContentLoaded`` event rather than the page's
``onload`` event, so processing of mathematics can start earlier)
..
10. Set ``MathJax.isReady`` to ``true``
..
11. Perform the typesetting pass (preprocessors and processors)
- Post the ``Begin Typeset`` startup signal
- Post the ``Begin PreProcess`` hub signal
- Run the registered preprocessors
- Post the ``End PreProcess`` hub signal
- Clear the hub signal history
- Post the ``Begin Process`` hub signal
- Process the math script elements on the page
- There are a number of Hub signals generated during math
processing, including a signal that a ``Math`` action is
starting (with a parameter indicating what action that is),
``Begin`` and ``End Math Input`` messages, and ``Begin`` and
``End Math Output`` signals.
- Each new math element generates a ``New Math`` hub signal
with the math element's ID
- Post the ``End Process`` hub signal
- Post the ``End Typeset`` startup signal
..
12. Jump to the location specified in the URL's hash reference, if
any.
..
13. Initiate timers to load the zoom and menu code, if it hasn't
already been loading in the configuration (so it will be ready
when the user needs it).
..
14. Post the ``End`` startup signal
The loading of the jax and extensions in steps 5 and 6 are now done in
parallel, rather than sequentially. That is, all the jax and extensions
are requested simultaneously, so they load concurrently. That means they
can load in any order, and that the begin and end signals for the jax and
extensions can be intermixed. (In general, you will get `Begin Jax`
followed by `Begin Extensions`, but the order of `End Jax` and `End
Extensions` will depend on the files being loaded.) Both 5 and 6 must
complete, however, before 7 will be performed.
See the `test/sample-signals.html
<http://cdn.mathjax.org/mathjax/latest/test/sample-signals.html>`_ file
to see the signals in action.

67
docs/html/_sources/synchronize.txt
View File

@ -1,67 +0,0 @@
.. _synchronization:
************************************
Synchronizing your code with MathJax
************************************
MathJax performs much of its activity asynchronously, meaning that
the calls that you make to initiate these actions will return before
the actions are completed, and your code will continue to run even
though the actions have not been finished (and may not even be started
yet). Actions such as loading files, loading web-based fonts, and
creating stylesheets all happen asynchronously within the browser, and
since JavaScript has no method of halting a program while waiting for
an action to complete, synchronizing your code with these types of
actions is made much more difficult. MathJax uses three mechanisms to
overcome this language shortcoming: callbacks, queues, and signals.
**Callbacks** are functions that are called when an action is
completed, so that your code can continue where it left off when the
action was initiated. Rather than have a single routine that
initiates an action, waits for it to complete, and then goes on, you
break the function into two parts: a first part that sets up and
initiates the action, and a second that runs after the action is
finished. Callbacks are similar to event handlers that you attach to
DOM elements, and are called when a certain action occurs. See the
:ref:`Callback Object <api-callback>` reference page for details of
how to specify a callback.
**Queues** are MathJax's means of synchronizing actions that must be
performed sequentially, even when they involve asynchronous events
like loading files or dynamically creating stylesheets. The actions
that you put in the queue are `Callback` objects that will be performed
in sequence, with MathJax handling the linking of one action to the
next. MathJax maintains a master queue that you can use to
synchronize with MathJax, but you can also create your own private
queues for actions that need to be synchronized with each other, but
not to MathJax as a whole. See the :ref:`Queue Object <api-queue>`
reference page for more details.
**Signals** are another means of synchronizing your own code with
MathJax. Many of the important actions that MathJax takes (like
typesetting new math on the page, or loading an external component)
are "announced" by posting a message to a special object called a
`Signal`. Your code can register an interest in receiving one or more
of these signals by providing a callback to be called when the signal
is posted. When the signal arrives, MathJax will call your code.
This works somewhat like an event handler, except that many different
types of events can go through the same signal, and the signals have a
"memory", meaning that if you register an interest in a particular
type of signal and that signal has already occurred, you will be told
about the past occurrences as well as any future ones. See the
:ref:`Signal Object <api-signal>` reference page for more details.
See also the `test/sample-signals.html
<http://cdn.mathjax.org/mathjax/latest/test/sample-signals.html>`_
file in the MathJax ``test`` directory for a working example of using
signals.
Each of these is explained in more detail in the links below:
.. toctree::
:maxdepth: 1
Using Callbacks <callbacks>
Using Queues <queues>
Using Signals <signals>

2013
docs/html/_sources/tex.txt
View File

File diff suppressed because it is too large Load Diff

254
docs/html/_sources/typeset.txt
View File

@ -1,254 +0,0 @@
.. _typeset-math:
**************************
Modifying Math on the Page
**************************
If you are writing a dynamic web page where content containing
mathematics may appear after MathJax has already typeset the rest of
the page, then you will need to tell MathJax to look for mathematics
in the page again when that new content is produced. To do that, you
need to use the :meth:`MathJax.Hub.Typeset()` method. This will cause
the preprocessors (if any were loaded) to run over the page again, and
then MathJax will look for unprocessed mathematics on the page and
typeset it, leaving unchanged any math that has already been typeset.
You should not simply call this method directly, however. Because
MathJax operates asynchonously (see :ref:`Synchronizing with MathJax
<synchronization>` for details), you need to be sure that
your call to :meth:`MathJax.Hub.Typeset()` is synchronized with the
other actions that MathJax is taking. For example, it may already be
typesetting portions of the page, or it may be waiting for an output
jax to load, etc., and so you need to queue the typeset action to be
performed after MathJax has finished whatever else it may be doing.
That may be immediately, but it may not, and there is no way to tell.
To queue the typeset action, use the command
.. code-block:: javascript
MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
This will cause MathJax to typeset the page when it is next able to do
so. It guarantees that the typesetting will synchronize properly
with the loading of jax, extensions, fonts, stylesheets, and other
asynchronous activity, and is the only truly safe way to ask MathJax
to process additional material.
The :meth:`MathJax.Hub.Typeset()` command also accepts a parameter
that is a DOM element whose content is to be typeset. That could be
a paragraph, or a ``<div>`` element, or even a MathJax math
``<script>`` tag. It could also be the DOM `id` of such an object, in
which case, MathJax will look up the DOM element for you. So
.. code-block:: javascript
MathJax.Hub.Queue(["Typeset",MathJax.Hub,"MathExample"]);
would typeset the mathematics contained in the element whose `id` is
``MathExample``. This is equivalent to
.. code-block:: javascript
var math = document.getElementById("MathExample");
MathJax.Hub.Queue(["Typeset",MathJax.Hub,math]);
If no element or element `id` is provided, the whole document is
typeset.
Note that the :meth:`MathJax.Hub.Queue()` method will return
immediately, regardless of whether the typesetting has taken place or
not, so you can not assume that the mathematics is visible after you
make this call. That means that things like the size of the container
for the mathematics may not yet reflect the size of the typeset
mathematics. If you need to perform actions that depend on the
mathematics being typeset, you should push *those* actions onto the
``MathJax.Hub.queue`` as well.
This can be quite subtle, so you have to think carefully about the
structure of your code that works with the typeset mathematics. Also,
the things you push onto the queue should be `Callback` objects that
perform the actions you want when they are called, not the *results*
of calling the functions that do what you want.
Manipulating Individual Math Elements
=====================================
If you are not changing a complete DOM structure, but simply want to
update the contents of a single mathematical equation, you do not need
to use ``innerHTML`` and :meth:`MathJax.Hub.Typeset()` to preprocess
and process an element's new content. Instead, you can ask MathJax to
find the `element jax` for the math element on the page, and use its
methods to modify and update the mathematics that it displays.
For example, suppose you have the following HTML in your document
.. code-block:: html
<div id="MathDiv">
The answer you provided is: \({}\).
</div>
and MathJax has already preprocessed and typeset the mathematics
within the div. A student has typed something elsewhere on the page,
and you want to typeset their answer in the location of the
mathematics that is already there. You could replace the entire
contents of the `MathDiv` element and call
:meth:`MathJax.Hub.Typeset()` as described above, but there is a more
efficient approach, which is to ask MathJax for the element jax for
the mathematics, and call its method for replacing the formula shown
by that element. For example:
.. code-block:: javascript
var math = MathJax.Hub.getAllJax("MathDiv")[0];
MathJax.Hub.Queue(["Text",math,"x+1"]);
This looks up the list of math elements in the `MathDiv` element
(there is only one) and takes the first one (element 0) and stores it
in ``math``. This is an `element jax` object (see the :ref:`Element
Jax <api-element-jax>` specification for details), which has a
:meth:`Text()` method that can be used to set the input text of the
math element, and retypeset it.
Again, since the typesetting should be synchronized with other actions
of MathJax, the call should be pushed onto the MathJax processing
queue using :meth:`MathJax.Hub.Queue()`, as shown above, rather than
called directly. The example above performs the equivalent of
``math.Text("x+1")`` as soon as MathJax is able to do so. Any
additional actions that rely on the expression ``x+1`` actually
showing on screen should also be pushed onto the queue so that they
will not occur before the math is typeset.
The actions you can perform on an element jax include:
.. describe:: Text(newmath)
to set the math text of the element to `newmath` and typeset.
.. describe:: Rerender()
to remove the output and reproduce it again (for example, if
CSS has changed that would alter the spacing of the
mathematics). Note that the internal representation isn't
regenerated; only the output is.
.. describe:: Reprocess()
to remove the output and then retranslate the input into the
internal MathML and rerender the output.
.. describe:: Remove()
to remove the output for this math element (but not
the original ``<script>`` tag).
.. describe:: needsUpdate()
to find out if the mathematics has changed so that its output
needs to be updated.
.. describe:: SourceElement()
to obtain a reference to the original
``<script>`` object that is associated with this element jax.
Note that once you have located an element jax, you can keep using it
and don't have to look it up again. So for the example above, if the
student is going to be able to type several different answers that you
will want to typeset, you can look up the element jax once at the
beginning after MathJax has processed the page the first time, and
then use that result each time you adjust the mathematics to be
displayed.
To get the element jax the first time, you need to be sure that you
ask MathJax for it **after** MathJax has processed the page the first
time. This is another situation where you want to use the MathJax
queue. If your startup code performs the commands
.. code-block:: javascript
var studentDisplay = null;
MathJax.Hub.Queue(function () {
studentDisplay = MathJax.Hub.getAllJax("MathDiv")[0];
});
then you can use
.. code-block:: javascript
MathJax.Hub.Queue(["Text",studentDisplay,studentAnswer])
to change the student's answer to be the typeset version of whatever
is in the ``studentAnswer`` variable.
Here is a complete example that illustrates this approach. Note,
however, that Internet Explorer does not fire the ``onchange`` event
when you press RETURN, so this example does not work as expected in
IE. A more full-featured version that addresses this problem is
available in `test/sample-dynamic.html
<http://cdn.mathjax.org/mathjax/latest/test/sample-dynamic.html>`_.
.. code-block:: html
<html>
<head>
<title>MathJax Dynamic Math Test Page</title>
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {
inlineMath: [["$","$"],["\\(","\\)"]]
}
});
</script>
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML-full">
</script>
</head>
<body>
<script>
//
// Use a closure to hide the local variables from the
// global namespace
//
(function () {
var QUEUE = MathJax.Hub.queue; // shorthand for the queue
var math = null; // the element jax for the math output.
//
// Get the element jax when MathJax has produced it.
//
QUEUE.Push(function () {
math = MathJax.Hub.getAllJax("MathOutput")[0];
});
//
// The onchange event handler that typesets the
// math entered by the user
//
window.UpdateMath = function (TeX) {
QUEUE.Push(["Text",math,"\\displaystyle{"+TeX+"}"]);
}
})();
</script>
Type some TeX code:
<input id="MathInput" size="50" onchange="UpdateMath(this.value)" />
<p>
<div id="MathOutput">
You typed: ${}$
</div>
</body>
</html>
There are a number of additional example pages at `test/examples.html
<http://cdn.mathjax.org/mathjax/latest/test/examples.html>`_ that
illustrate how to call MathJax dynamically or perform other actions
with MathJax.

259
docs/html/_sources/upgrade.txt
View File

@ -1,259 +0,0 @@
.. _upgrade:
***********************************
Migrating from MathJax v1.0 to v1.1
***********************************
MathJax v1.1 fixes a number of bugs in v1.0, and improves support for
new versions of browsers and mobile devices. It includes changes to
increase its performance, and to make it more compliant with HTML5. It
has more flexible configuration options, and the ability to load
configuration files that combine multiple files into a single one to
increase loading speed when MathJax starts up. Finally, MathJax.org now
offers MathJax as a web service through a distributed "cloud" server.
This document describes the changes you may need to make to your MathJax
configurations in order to take advantage of these improvements.
Configuration Changes
=====================
The main changes that you will see as a page author are in the way that
MathJax can be loaded and configured. If you have been using in-line
configuration by putting a :meth:`MathJax.Hub.Config()` call in the body of
the ``<script>`` tag that loads MathJax, then your site should work
unchanged with version 1.1 of MathJax. You may wish to consider moving to
the new HTML5-compliant method of configuring MathJax, however, which uses
a separate ``<script>`` tag to specify the configuration. That tag should
come **before** the one that loads ``Mathjax.js``, and should have
``type="text/x-mathjax-config"`` rather than ``type="text/javascript"``.
For example,
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js">
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js"]
});
</script>
would become
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js"]
});
</script>
<script type="text/javascript" src="/MathJax/MathJax.js"></script>
instead. This will make sure your pages pass HTML5 validation. Be sure
that you put the configuration block **before** the script that loads
MathJax. See :ref:`Loading and Configuring MathJax <loading>` for more
details.
If your page simply loads ``MathJax.js`` and relies on
``config/MathJax.js``, then you will need to modify your ``<script>`` tag
in order to use MathJax v1.1. This is because MathJax no longer loads a
default configuration file; you are required to explicitly specify the
configuration file if you use one. Furthermore, the name of the
``config/MathJax.js`` file was a source of confusion, so it has been
renamed ``config/default.js`` instead. Thus, if you used
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js"></script>
in the past, you should replace it with
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js?config=default"></script>
instead. If you don't do this, you will receive a warning message that
directs you to a page that explains how to update your script tags to use
the new configuration format.
Combined Configurations
=======================
New with version 1.1 is the ability to combine several files into a single
configuration file, and to load that via the same script that loads
MathJax. This should make configuring MathJax easier, and also helps to
speed up the initial loading of MathJax's components, since only one file
needs to be downloaded.
MathJax comes with four pre-built configurations, and our hope is that one
of these will suit your needs. They are described in more detail in the
:ref:`Using a Configuration File <config-files>` section. To load one,
add ``?config=filename`` (where ``filename`` is the name of the
configuration file without the ``.js``) to the URL that loads
``MathJax.js``. For example
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js">
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js","AMSmath.js","AMSsymbols.js"]
});
</script>
could be replaced by the single line
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js?config=TeX-AMS_HTML"></script>
In this way, you don't have to include the in-line configuration, and all
the needed files will be downloaded when MathJax starts up. For complete
details about the contents of the combined configuration files, see the
:ref:`Common Configurations <common-configurations>` section.
If you want to use a pre-defined configuration file, but want to modify some
of the configuration parameters, you can use both a
``text/x-mathjax-config`` block and a ``config=filename`` parameter in
combination. For example,
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {
inlineMath: [ ['$','$'], ['\\(','\\)'] ],
processEscapes: true
}
});
</script>
<script type="text/javascript" src="/MathJax/MathJax.js?config=TeX-AMS_HTML"></script>
would load the ``TeX-AMS_HTML`` configuration file, but would reconfigure
the inline math delimiters to include ``$...$`` in addition to
``\(...\)``, and would set the ``processEscapes`` parameter to ``true``.
Loading MathJax from the CDN
============================
The MathJax installation is fairly substantial (due to the large number of
images needed for the image fonts), and so you may not want to (or be able
to) store MathJax on your own server. Keeping MathJax up to date can also
be a maintenance problem, and you might prefer to let others handle that
for you. In either case, using the MathJax distributed network service may be
the best way for you to obtain MathJax. That way you can be sure you are
using an up-to-date version of MathJax, and that the server will be fast
and reliable.
To use the MathJax CDN service, simply load MathJax as follows:
.. code-block:: html
<script type="text/javascript"
src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</scrip>
Of course, you can load any configuration file that you wish, or use a
``text/x=mathajx-config`` block to configure MathJax in-line.
:ref:`More details <loading-CDN>` are available, if you need them.
The use of ``cdn.mathjax.org`` is governed by its `terms of service
<http://www.mathjax.org/download/mathjax-cdn-terms-of-service/>`_, so be
sure to read that before linking to the MathJax CDN server.
Change in default TeX delimiters
================================
In addition to the fact that MathJax v1.1 no longer loads a default
configuration file, there is a second configuration change that could
affect your pages. The ``config/MathJax.js`` file properly configured the
`tex2jax` preprocessor to use only ``\(...\)`` and not ``$...$`` for in-line
math delimiters, but the `tex2jax` preprocessor itself incorrectly
defaulted to including ``$...$`` as in-line math delimiters. The result
was that if you used in-line configuration to specify the ``tex2jax``
preprocessor, single-dollar delimiters were enabled by default, while if
you used file-based configuration, they weren't.
This inconsistency was an error, and the correct behavior was supposed to
have the single-dollar delimiters disabled in both cases. This is now
true in v1.1 of MathJax. This means that if you used in-line
configuration to specify the `tex2jax` preprocessor, you will need to
change your configuration to explicitly enable the single-dollar
delimiters if you want to use them.
For example, if you had
.. code-block:: html
<script type="text/javascript" src="/MathJax/MathJax.js">
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js"]
});
</script>
and you want to use single-dollar delimiters for in-line math, then you
should replace this with
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
jax: ["input/TeX","output/HTML-CSS"],
extensions: ["tex2jax.js"],
tex2jax: {
inlineMath: [ ['$','$'], ['\\(','\\)'] ],
processEscapes: true
}
});
</script>
<script type="text/javascript" src="/MathJax/MathJax.js"></script>
The same technique can be used in conjunction with a combined
configuration file. For example
.. code-block:: html
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {
inlineMath: [ ['$','$'], ['\\(','\\)'] ],
processEscapes: true
}
});
</script>
<script type="text/javascript" src="/MathJax/MathJax.js?config=TeX-AMS_HTML"></script>
will load the pre-defined ``TeX-AMS_HTML`` configuration, but will modify
the settings to allow ``$...$`` delimiters, and to process ``\$`` to
produce dollar signs within the text of the page.
New Distribution Location
=========================
Version 1.0 of MathJax was distributed through `SourceForge`, but the
development of MathJax has switched to `GitHub
<https://github.com/mathjax/MathJax/>`_, which is now the primary location
for MathJax source code and distributions. The SourceForge repository will
no longer be actively maintained (and hasn't been since November 2010), and
so you will not be able to obtain updates through ``svn`` if you checked
out MathJax from there.
You may be able to switch to using the MathJax CDN (see above) rather than
hosting your own copy of MathJax, and avoid the problem of updates all
together. If you must install your own copy, however, you should follow
the instructions at :ref:`Installing and Testing MathJax <installation>`,
using either ``git`` or ``svn`` as described to obtain your copy from
GitHub. This will allow you to keep your copy of MathJax up to date as
development continues.
We apologize for the inconvenience of having to switch distributions, but
the git-to-svn bridge we tried to implement to keep both copies in synch
turned out to be unreliable, and so the SourceForge distribution was
retired in favor of the GitHub site.

172
docs/html/_sources/whats-new-1.1.txt
View File

@ -1,172 +0,0 @@
.. _whats-new-1.1:
**************************
What's New in MathJax v1.1
**************************
MathJax version 1.1 includes a number of important improvements and
enhancements over version 1.0. We have worked hard to fix bugs, improve
support for browsers and mobile devices, process TeX and MathML better, and
increase MathJax's performance.
In addition to these changes, MathJax.org now offers MathJax as a network
service. Instead of having to install MathJax on your own server, you can
link to our content delivery network (CDN) to get fast access to
up-to-date and past versions of MathJax. See :ref:`Loading MathJax from
the CDN <loading-CDN>` for more details.
The following sections outline the changes in v1.1:
Optimization
============
* Combined configuration files that load all the needed files in one piece
rather than loading them individually. This simplifies configuration
and speeds up typesetting of the mathematics on the page.
* Improved responsiveness to mouse events during typesetting.
* Parallel downloading of files needed by MathJax, for faster startup
times.
* Shorter timeout for web fonts, so if they can't be downloaded, you don't
have to wait so long.
* Rollover to image fonts if a web font fails to load (so you don't have
to wait for *every* font to fail.
* The MathJax files are now packed only with `yuicompressor` rather than a
custom compressor. The CDN serves gzipped versions, which end up being
smaller than the gzipped custom-packed files.
* Improved rendering speed in IE by removing ``position:relative`` from
the style for mathematics.
* Improved rendering speed for most browsers by isolating the mathematics
from the page during typesetting (avoids full page reflows).
Enhancements
============
* Allow the input and output jax configuration blocks to specify extensions
to be loaded when the jax is loaded (this avoids needing to load them up
front, so they don't have to be loaded on pages that don't include
mathematics, for example).
* Better handling of background color from style attributes.
* Ability to pass configuration parameters via script URL.
* Support HTML5 compliant configuration syntax.
* Switch the Git repository from storing the fonts in `fonts.zip` to
storing the `fonts/` directory directly.
* Improved About box.
* Added a minimum scaling factor (so math won't get too small).
TeX Support
============
* Added support for ``\href``, ``\style``, ``\class``, ``\cssId``.
* Avoid recursive macro definitions and other resource consumption possibilities.
* Fix for ``\underline`` bug.
* Fix for bug with ``\fbox``.
* Fix height problem with ``\raise`` and ``\lower``.
* Fix problem with ``\over`` used inside array entries.
* Fix problem with nesting of math delimiters inside text-mode material.
* Fix single digit super- and subscripts followed by punctuation.
* Make sure `movablelimits` is off for ``\underline`` and related macros.
* Fix problem with dimensions given with ``pc`` units.
MathML Support
==============
* Fix ``&lt;`` and ``&amp;`` being translated too early.
* Handle self-closing tags in HTML files better.
* Combine adjacent relational operators in ``<mo>`` tags.
* Fix entity name problems.
* Better support for MathML namespaces.
* Properly handle comments within MathML in IE.
* Properly consider ``<mspace>`` and ``<mtext>`` as space-like.
* Improved support for ``<maction>`` with embellished operators.
Other Bug Fixes
===============
* Fixed CSS bleed through with zoom and other situations.
* Fixed problems with ``showMathMenuMSIE`` when set to ``false``.
* Replaced illegal prefix characters in cookie name.
* Improved placement of surd for square roots and n-th roots.
* Fixed layer obscuring math from MathPlayer for screen readers.
* Newlines in CDATA comments are now handled properly.
* Resolved conflict between `jsMath2jax` and `tex2jax` both processing the
same equation.
* Fixed problem with ``class="tex2jax_ignore"`` affecting the processing of
sibling elements.
Browser Support
===============
**Android**
* Added detection and configuration for Android browser.
* Allow use of OTF web fonts in Android 2.2.
**Blackberry**
* MathJax now works with OS version 6.
**Chrome**
* Use OTF web fonts rather than SVG fonts for version 4 and above.
**Firefox**
* Added Firefox 4 detection and configuration.
* Fix for extra line-break bug when displayed equations are in
preformatted text.
* Updated fonts so that FF 3.6.13 and above can read them.
**Internet Explorer**
* Changes for compatibility with IE9.
* Fix for IE8 incorrectly parsing MathML.
* Fix for IE8 namespace problem.
* Fix for null ``parentNode`` problem.
* Fix for ``outerHTML`` not quoting values of attributes.
**iPhone/iPad**
* Added support for OTF web fonts in iOS4.2.
**Nokia**
* MathJax now works with Symbian\ :sup:`3`\ .
**Opera**
* Prevent Opera from using STIX fonts unless explicitly requested via the
font menu (since Opera can't display many of the characters).
* Fixed bad em-size detection in 10.61.
* Fixed a problem with the About dialog in Opera 11.
**Safari**
* Use OTF web fonts for Safari/PC.
**WebKit**
* Better version detection.

718
docs/html/_sources/whats-new-2.0.txt
View File

@ -1,718 +0,0 @@
.. _whats-new-2.0:
**************************
What's New in MathJax v2.0
**************************
MathJax version 2.0 includes many new and improved features, including
much better speeds in Internet Explorer, a new AsciiMath input
processor, a new :term:`SVG` output processor, support for additional
LaTeX commands, and many bug fixes, to name just a few of the changes.
Major speed improvement for HTML-CSS output, particularly in IE
===============================================================
The HTML-CSS output processing was redesigned to avoid the page
reflows that were the main source of the speed problem in Internet
Explorer 8 and 9. For test pages having between 20 and 50 typeset
expressions, we see an 80% reduction in output processing time for
IE8, a 50% reduction for IE9, and between 15% and 25% reduction for
most other browsers over the corresponding v1.1a times. Since the
processing time in v1.1a grows non-linearly in IE, you should see even
larger savings for pages with more equations when using v2.0. Forcing
IE7 emulation mode is no longer necessary (and indeed is no longer
recommended).
Reduced flickering during typsetting
====================================
In the past, each expression was displayed as soon as it was typeset,
which caused a lot of visual flickering as MathJax processed the page.
In v2.0, the output is processed in blocks so that typeset expressions
are revealed in groups. This reduces the visual distraction, and also
speeds up the processing. The number of equations in a block can be
controlled through the ``EqnChunk`` parameter in the HTML-CSS or SVG
block of your configuration. See the :ref:`configuration options for
HTML-CSS <configure-HTML-CSS>` and :ref:`configuration options for SVG
<configure-SVG>` pages for details.
If the page URL includes a hash reference (a link to a particular
location within the page), MathJax v2.0 will jump to that location
after the page has finished typsetting. (Since the size of the page
may have changed due to the mathematical typsetting, that location may
no longer be visible on screen, so MathJax moves there when it is done
with the initial typesetting.) You can control this behavior with the
``positionToHash`` parameter in the main section of your
configuration. See the :ref:`core configuration options
<configure-hub>` page for details.
Automatic equation numbering of TeX formulas
============================================
The TeX input jax now can be configured to add equation numbers
(though the default is not to number equations so that existing pages
will not change their appearance). This is controlled through the
``equationNumbers`` section of the ``TeX`` block of your configuration
(see the :ref:`equation numbering <tex-eq-numbers>` section for
details). You can request that the numbering follow the AMS-style
numbering of environments, or you can request that every displayed
equation be numbered. There are now ``\label``, ``\ref``, and
``\eqref`` commands to make it easier to link to particular equations
within the document.
Automatic line breaking of long displayed equations
===================================================
MathJax now implements the MathML3 specification for automatic line
breaking of displayed equations in its HTML-CSS output. This is
disabled by default, but can be enabled via the ``linebreaks`` section
of the ``HTML-CSS`` or ``SVG`` block of your configuration (see the
:ref:`automatic line breaking <automatic-linebreaking>` section for
details). Note that automatic line breaking only applies to displayed
equations, not in-line equations, unless they are themselves longer
than a line. The algorithm uses the nesting depth, the type of
operator, the size of spaces, and other factors to decide on the
breakpoints, but it does not know the meaning of the mathematics, and
may not choose the optimal breakpoints. We will continue to work on
the algorithm as we gain information from its actual use in the field.
New AsciiMath input jax and SVG output jax
==========================================
MathJax currently processes math in either :term:`TeX` and
:term:`LaTeX` format, or :term:`MathML` notation; version 2.0 augments
that to include :term:`AsciiMath` notation (see `the ASCIIMathML
home page <http://www1.chapman.edu/~jipsen/mathml/asciimath.html>`_
for details on this format). This is a notation that is easier for
students to use than TeX, and has been requested by the user
community. See the :ref:`AsciiMath support <AsciiMath-support>` page
for details.
In addition to the HTML-CSS and Native MathML output available in
v1.1, MathJax v2.0 includes an :term:`SVG`-based output jax. This should
prove to be more reliable than the HTML-CSS output, as it avoids some
CSS, web-font, and printing issues that the HTML-CSS output suffers
from, and it currently has no browser-dependent code. The SVG mode
even works in some ebook readers (like Apple iBooks and Calibre). See
the :ref:`output formats <output-formats>` documentation for details.
New combined configuration files
================================
Pre-defined configuration files that include the AsciiMath and SVG
processors are now available with MathJax v2.0. These include
``AM_HTMLorMML``, ``TeX-AMS-MML_SVG``, and ``TeX-MML-AM_HTMLorMML``.
See the :ref:`common configurations <config-files>` section for details.
MathJax contextual menu now available on mobile devices
=======================================================
MathJax v2.0 provides access to its contextual menu in mobile devices
that are based on the WebKit (Safari) and Gecko (Firefox) engines.
For Mobile Firefox, the menu is accessed by a tap-and-hold on any
expression rendered by MathJax (this is Mobile Firefox's standard
method of triggering a contextual menu). In Mobile Safari, use a
double-tap-and-hold (you may need to zoom in a bit to be able to
accomplish this). This is the first step toward providing a better
interface for mobile devices.
Improved support for screen readers
===================================
Some issues surrounding the use of screen readers and their
interaction with MathPlayer have been resolved in MathJax v2.0. In
particular, there are additional menu items that allow the user finer
control over some aspects of MathJax's interface that were interfering
with some screen readers' ability to properly identify the
mathematics. Several stability issues with MathPlayer have also been
addressed. In Internet Explorer when MathPlayer is installed, there
is now a new contextual menu item to allow you to specify what events
are handled by MathJax and what should be handled by MathPlayer. This
gives you finer control over MathPlayer's interaction with some screen
readers.
Many new TeX additions and enhancements
=======================================
* New `mhchem` chemistry extension (adds ``\ce``, ``\cf``, and ``\cee`` macros)
* New `cancel` extension (adds ``\cancel``, ``\bcancel``, ``\xcancel``, and ``\cancelto`` macros)
* New `extpfeil` extension (adds more stretchy arrows)
* New `color` extension (makes ``\color`` work as a switch, as in LaTeX).
Adds ``\definecolor``, other color models, LaTeX named colors,
``\colorbox``, ``\fcolorbox``, etc.
* New `begingroup` extension to allow macro definitions to be
localized. Adds ``\begingroup`` and ``\endgroup`` for isolating macro
declarations, and defines ``\let``, ``\renewenvironment``, ``\global``, and
``\gdef``.
* New `enclose` extension to give TeX access to ``<menclose>`` elements.
Adds ``\enclose{type}[attributes]{math}`` macro.
* New `action` extension to give TeX access to ``<maction>`` elements.
Adds ``\mathtip{math}{tip}``, ``\texttip{math}{tip}``, and
``\toggle{math1}{math2}...\endtoggle`` macros.
* New ``\mmToken{type}[attributes]{text}`` macro for producing ``<mo>``,
``<mi>``, ``<mtext>``, and other token MathML elements directly.
* New ``\bbox[color;attributes]{math}`` macro to add background color,
padding, borders, etc.
* New ``\middle`` macro for stretchy delimiters between ``\left`` and ``\right``.
* New ``\label``, ``\ref``, and ``\eqref`` macros for numbered equations.
* Better implementation of ``\not`` so it produces proper MathML when possible.
* Better implementation of ``\dots`` that selects ``\ldots`` or ``\cdots``
depending on the context.
* Better implementation of ``\cases`` that automatically uses ``\text`` on
the second entry in each row.
* Safer implementation of ``\require`` that only allows loading from
extensions directory.
* Allow ``\newcomand`` to provide a default parameter.
* Allow ``\\`` to take an optional argument that specifies additional
space between lines.
* Allow ``\\`` to be used anywhere (to force a line break), not just in
arrays.
* Allow optional alignment parameter for array, aligned, and gathered
environments.
See the :ref:`TeX support <TeX-support>` page for details on these
extensions and macros.
Font enhancements
=================
* Work around for the OS X Lion STIX font problem.
* Support for STIX-1.1 fonts (detection of which version you have,
and use data appropriate for that).
* New WOFF versions of the web fonts (smaller, so faster to
download).
* Data for more stretchy characters in HTML-CSS output.
* Add support for Unicode planes 1 through 10 (not just the Math
Alphabet block) in HTML-CSS output.
* Increased timeout for web fonts (since it was switching to image
fonts too often, especially for mobile devices).
* Only switch to image fonts if the first web font fails to load (if
we can access one, assume we can access them all).
* Allow ``<mtext>`` elements to use the page font rather than MathJax
fonts (optionally). This is controlled by the ``mtextFontInerhit``
configuration parameter for HTML-CSS and SVG output jax.
* Provide better control over the font used for characters that are
not in the MathJax fonts.
* Allow Firefox to use web-based fonts when a local URL uses MathJax
from the CDN (in the past it would force image fonts when that was
not necessary).
Interface improvements
======================
* The MathJax contextual menu has been reorganized to make it easier
to get the source view, and to control the parameters for
MathPlayer in IE.
* The MathJax contextual menu is available in mobile devices (see
description above).
* Warning messages are issued if you switch renderers to one that is
inappropriate for your browser.
* MathJax now starts processing the page on the ``DOMContentLoaded``
event rather than the page ``onload`` event (this allows the
mathematics to appear sooner).
* Native MathML output is now scaled to better match the surrounding
font (like it is for HTML-CSS output).
* Better CSS styling for NativeMML output in Firefox in order to
handle ``\cal`` and other fonts.
* MathML output now (optionally) includes class names to help mark
special situations generated by the TeX input jax. (This lets the
MathML from the Show Source menu item better reproduce the original
TeX output.)
* MathJax now loads the menu and zoom code (if they haven't been
loaded already) after the initial typesetting has occured so that
they will be available immediately when a user needs those
features, but do not delay the initial typesetting of the
mathematics.
* For the `tex2jax` preprocessor, the ``processClass`` can now be
used to override the ``skipTags`` to force a tag that is usually
skipped to have its contents be processed.
* The `noErrors` and `noUndefined` extensions can now be disabled via
a configuration option (since they are included in many of the
combined configuration files). See the `noErrors` and
`noUndefined` sections of the :ref:`TeX support
<TeX-support>` page for more information.
* There is a new :meth:`MathJax.Hub.setRenderer()` function that can
be used to switch the current renderer. See the :ref:`MathJax Hub
API <api-hub>` documentation for details.
* A user-defined macros is no longer overridden if an extension is
loaded that redefines that macro.
* Improved web-font detection reliability.
.. _important-changes-2.0:
Important changes from previous versions
========================================
* The default renderer for Firefox has been changed from `NativeMML` to
`HTML-CSS` (in those configurations that choose between the two).
The only browser that defaults to `NativeMML` is now IE with
MathPlayer installed. You can configure this to your liking using
the :ref:`MMLorHTML configuration options <configure-MMLorHTML>`.
* `NativeMML` output will now be selected in IE9 when MathPlayer is
present (since IE9 was released the same day as MathJax v1.1a, and
there had been problems with IE9 beta releases, we weren't sure if
MathPlayer would work with the official release, and so did not
select NativeMML by default.)
* The performance improvements in IE8 and IE9 now make it unnecessary
to use a ``<meta>`` tag to force IE7 emulation mode. In fact IE9 in
IE9 standards mode now runs faster than IE9 in IE7 standards mode,
and IE8 in IE8 standards mode is comparable to IE8 in IE7 standards
mode. We now recommend that you use
.. code-block:: html
<meta http-equiv="X-UA-Compatible" content="IE=edge">
to obtain the highest emulation mode available in IE, which
will be the fastest one for MathJax 2.0.
* The `tex2jax` preprocessor now balances braces when looking for the
closing math delimiter. That allows expressions like
.. code-block:: latex
$y = x^2 \hbox{ when $x > 2$}$
to be properly parsed as a single math expression rather than two
separate ones with unbalanced braces. The old behavior can be
obtained by setting ``balanceBraces`` to false in the ``tex2jax``
block of your configuration. (See the :ref:`tex2jax configuration
options <configure-tex2jax>` for details.)
* If you are hosting your own copy of MathJax on your server, and
that copy is being used from pages in a different domain, you will
have set up the access control paramters for the font directory to
allow Firefox to access the font files properly. Since MathJax 2.0
includes fonts in WOFF format, you will need to include ``woff`` in
you access control declaration for the fonts. E.g., use
::
<FilesMatch "\.(ttf|otf|eot|woff)$">
<IfModule mod_headers.c>
Header set Access-Control-Allow-Origin "*"
</IfModule>
</FilesMatch>
in the ``.htaccess` file for the ``Mathjax/fonts`` directory if you
are using the Apache web server. See :ref:`Notes about shared
installations <cross-domain-linking>` for details.
* The ``\cases`` macro now properly places the second column in text
mode not math mode. In the past, one needed to use ``\text`` in
the second column to achieve the proper results; pages that did
this will still work properly in v2.0. Pages that took advantage
of the math mode in the second column will need to be adjusted.
* The ``\dots`` macro now produces ``\ldots`` or ``\cdots`` depending
on the context (in the past, ``\dots`` always produced ``\ldots``).
* A one pixel padding has been added above and below HTML-CSS and SVG
output so that math on successive lines of a paragraph won't bump
into each other.
* There is a new `MathPlayer` submenu of the `Math Settings` menu in
the MathJax contextual menu that allows the user to control what
events are passed on to MathPlayer. This allows better control for
those using assistive devices like screen readers. When menu
events are being passed on to MathPlayer, the MathJax menu can be
obtained by ALT-clicking on a typeset expression (so the user can
still access MathJax's other features).
* In order to improve stability with IE when MathPlayer is installed,
MathJax now adds the namespace and object bindings that are needed
for MathPlayer at the time that Mathjax is first loaded, rather
than waiting for the `NativeMML` output jax to be loaded. Since
this is before the configuration information has been obtained,
this will happen regardless of whether the `NativeMML` output jax
is requested. This means that IE may ask the user to allow
MathPlayer to be used, and may show the MathPlayer splash dialog
even when MathPlayer is not in the end used by MathJax. Note that
this setup can only be performed if MathJax is loaded explicitly as
part of the initial web page; if it is injected into the page later
by adding a ``<script>`` tag to the page dynamically, then
MathPlayer will be set up when the `NativeMML` jax is loaded as in
the past, and some stability issues may occur if events are passed
to MathPlayer.
* The MathJax typesetting is now started on ``DOMContentLoaded``
rather than at the page ``onload`` event, when possible, so that
means MathJax may start typesetting the page earlier than in the
past. This should speed up typesetting one pages with lots of
images or side-bar content, for example.
* MathJax now attempts to determine whether the page's ``onload``
event had already occurred, and if it has, it does not try to wait
for the ``DOMContentLoaded`` or ``onload`` event before doing its
initial typeset pass. This means that it is no longer necessary to
call ``MathJax.Hub.Startup.onload()`` by hand if you insert MathJax
into the page dynamically (e.g., from a GreaseMonkey script).
* If the page URL includes a hash reference (a link to a particular
location within the page), MathJax v2.0 will jump to that location
after the page has finished typsetting. Since the size of the page
may have changed due to the mathematical typsetting, that location
may no longer be visible on screen, so MathJax moves there when it
is done with the initial typesetting. You can control this
behavior with the ``positionToHash`` parameter in the main section
of your configuration (see :ref:`core configuration options
<configure-hub>`).
* In the event that MathJax is not able to load the configuration file
you have specified in the script tag that loads ``MathJax.js`` via
``config=filename``, it will no longer issue the warning message
about a missing configuration. The configuration process changed
in v1.1, and that message was to help page maintainers update their
configurations, but it turns out that for users with slow network
connections, MathJax could time out waiting for the configuration
file and would issue the warning message in that case, even though
the page included the proper configuration. That should no longer
occur in MathJax v2.0.
Other enhancements
==================
* Use prioritized lists of callbacks for StartupHooks, MessageHooks,
LoadHooks, PreProcessors, and pre- and post-filters on the input jax.
* Updated operator dictionary to correspond to current W3C version.
* Improved browser detection for Gecko and WebKit browsers.
* Make prefilters and postfilters for all input jax, and make them into
hook lists rather than a single hook.
* Use ``<mi>`` rather than ``<mo>`` for ``\sin``, ``\cos``, and other
such functions, for ``\mathop{\rm...}`` and ``\operatorname``.
* Add ``&ApplyFunction;`` after ``\mathop{}`` and other macros that are
functions (e.g., ``\sin``).
* The ``MathJax_Preview`` style has been moved from ``HTML-CSS/jax.js`` to
``MathJax.js``, since it is common to all output.
* The `autobold` extension now uses ``\boldsymbol`` rather than
``\bf`` so that it will affect more characters.
* Make units of ``mu``'s be relative to the scriptlevel (as they
are supposed to be).
* Reorganized the event-handling code to make it more modular and reduce
redundancy in the different output jax.
* Modified CSS in `NativeMML` output for Firefox to use local copies of
the web fonts, if they are available.
* Error messages now have the MathJax contextual menu.
* Better handling of some characters not in the web fonts (remap to
locations where they exist, when possible).
* Better choice of accent characters in some cases.
* Better handling of pseudo-scripts (like primes).
* Better sizing of characters introduced by ``\unicode{}``, or
otherwise outside of the fonts known to MathJax.
* Provide a new extension to handle tagged equations better in
`HTML-CSS` output when there are floating elements that might
reduce the area available to displayed equations. (See the
HTML-CSS extensions section of the :ref:`output formats
<output-formats>` documentation for detais.)
* Use a text font for ``\it`` rather than the math italics, so
spacing is better.
* Handle italic correction better in `HTML-CSS` output
* Handle ``href`` attributes better, especially when on ``<math>``
elements.
* Allow ``\sqrt\frac{}{}`` without producing an error.
Other bug fixes
===============
* MathPlayer setup changed to prevent crashes.
* Moved remapping of ``<mo>`` contents to the output jax so that the
original contents aren't changed.
* Don't combine ``mathvariant`` with ``fontstyle`` or ``fontweight``
(as per the MathML specification).
* Isolate non-standard attributes on MathML elements so that they don't
interfere with the inner workings of MathJax.
* Properly handle width of border and padding in merrors in `HTML-CSS`
output.
* Properly handle lower-case Greek better.
* Process weight and style of unknown characters properly.
* Fixed spacing problems with ``\cong`` in MathJax web fonts .
* Choose better sizes for ``\widehat`` and ``\widetilde``
* Fixed problem with detecting em/ex sizes when uses in mobile devices
with small screen widths.
* Fixed MathML output when dimensions of ``mu``'s are used in TeX input.
* Better handling of table borders from TeX.
* Fixed some problems with table widths and heights, and spacing.
* Better handling of colored backgrounds in `HTML-CSS` output.
* Handle border and padding CSS styles better in `HTML-CSS` output.
* Fixed multline environment to put tags on bottom row when
``TagSide`` is set to ``right``.
* Force reflow after equations are typeset so that some rendering
problems in tables are corrected in Firefox and WebKit browsers.
* Fixed a number of bugs with the size of zoom boxes and the size of their
content.
* Have equations with tags zoom into a full-width zoom box to
accommodate the tag.
* Fixed positioning problem with zoom boxes in NativeMML mode.
* Don't allow mouse events on zoomed math.
* Fixed ``MathJax.Hub.getJaxFor()`` and ``MathJax.Hub.isJax()`` to
properly handle elements that are part of an output jax's output
(in particular, you can find the element jax from any DOM element
in the output).
* Fixed a number of font anomalies (problems in the data files).
* Fixed problem where ``<mspace>`` with a background color would not
always overlay previous items.
* Fixed a problem with colored ``<mspace>`` elements being too tall in
IE/quirks mode.
* Fixed problem where ``<mtable>`` with ``equalrows="true"`` would
not produce equal height rows.
* Allow ``<mpadded>`` background color to be specified exactly (i.e.,
without the 1px padding) when one of its dimensions is given
explicitly (or there is no content).
* Avoiding flicker problem with hover zoom trigger in Firefox.
* Fix ``\unicode`` bug with font names that include spaces.
* Remove internal multiple spaces in token elements as per the MathML
specification.
* Work around HTML5 removing namespaces, so that ``xmlns:xlink``
becomes ``xlink`` with no namespace, which confuses the XML parsers.
* Fix ``MathJax.Message.Set()`` and ``MathJax.Message.Clear()`` so
that a delay of 0 is properly handled.
* Produce better MathML for ``\bmod``, ``\mod``, and ``\pmod``.
* Don't allow Safari/Windows to use STIX fonts since it can't access
characters in Plane1 (the mathematical alphabets).
* Fix ``\thickapprox`` to use the correct glyph in `HTML-CSS` output
with MathJax web fonts.
* Make style attributes work on ``<mstyle>`` elements.
* Better handling of border and padding on MathML elements in
`HTML-CSS` output.
* Fixed error with size of ``\:`` space.
* Allow delimiter of ``.`` on ``\genfrac`` (it was accidentally rejected).
* Handle AMSmath control sequences with stars better (``\cs{*}`` no longer
counts as ``\cs*``).
* Fixed wrong character number in stretchy data for `U+221A`.
* Fixed ``<annotation-xml>`` to use the proper scaling in `HTML-CSS`
output.
* Fixed a problem with combining characters when they are used as
accents.
* Fixed a problem in Firefox with ``\mathchoice`` when the contents have
negative width.
* TeX input jax no longer incorrectly combines ``<mo>`` elements that have
different variants, styles, classes, or id's.
* Fixed the ``scriptlevel`` when ``<munderover>`` has base with
``movablelimits="true"`` in non-display mode.
* Fixed typo in implementation of ``SimpleSUPER``.
* Fixed typo in self-closing flag for ``<mprescript>`` tag.
* Prevent infinite loop if one of the jax fails to load (due to failure
to compile or timeout waiting for it to load).
* Fixed a whitespace issue in token elements with IE/quirks mode in
the `MathML` input jax.
* Make sure height is above depth when making spaces and rules in
`HTML-CSS` and `SVG` output.
* Fixed `HTML-CSS` tooltip to be work properly when a restart occurs
within the tooltip.
* Fixed problem with size of colored backgrounds on ``<mo>`` in some
circumstances in `HTML-CSS` output.
* Make ``\ulcorner``, etc. use more approprate unicode positions, and remap
those positions to the locations in the MathJax web fonts.
Some technical changes
======================
* Break the processing phase into two separate phases to do input
processing separately from output processing (they used to be
interleaved). This makes it easier to implement forward references
for the ``\ref`` macro.
* Make ``Font Preference`` menu honor the ``imageFont`` setting.
* Changed the name of the preview filter commands to ``previewFilter``
in all preprocessors.
* Make ``^`` and ``_`` be stretchy even though that isn't in the W3C
dictionary.
* Fixed `HTML-CSS` output problem when a multi-character token element has
characters taken from multiple fonts.
* Force message text to be black in FontWarnings and configuration
warnings.
* Added ``Find()`` and ``IndexOf()`` commands to menus to locate menu items.
* Added menu signals for post/unpost and activation of menu items.
* Added signals for typesetting of unknown characters.
* Added signals for zoom/unzoom.
* Added More signals for error conditions.
* Allow preferences to select MathML output for Safari with late enough
version.
* Improved `About MathJax` box.
* Have `tex2jax` handle empty delimiter arrays and don't scan page if
there is nothing to look for.
* Make delay following a `processing` message configurable and lengthen
it to make browser more responsive during typesetting.
* Make thin rules be in pixels to try to improve results in IE
(disappearing division lines).
* Mark all output elements as ``isMathJax``, so it can be used to identify
what elements are part of mathematical output.
* Force MathZoom and MathMenu to wait for the ``Begin Styles`` message
before inserting their styles so when they are included in the
combined files, the author can still configure them.
* Add default id's to the jax base object classes.
* Mark top-level math element as having a ``texError`` when it is one (to
make it easier to recognize).
* Have ``Update()`` method ask ElementJax to determine if it needs updating
(which in turn asks the associated input jax).
* Make ``Remove()`` work for just clearing output (without detaching) if
desired.
* Have ElementJax store input and output jax ID's rather than pointers
(to help avoid circular references for cleanup purposes).
* Move input/output jax and preprocessor registries from ``Hub.config`` to
Hub itself (they are not user configurable through ``Hub.Config``, and so
even though they are configurations, they don't belong there).
* Make sure embelished large ops are type ``OP`` not ``ORD`` to get spacing
right.
* Added ``MathJax.HTML.getScript()`` to get the contents of a script (needed
since it works differently in different browsers).
* Move code that prevents numbers from being treated as a unit for
super- and subscripts to the super- and subscript routine in the
`TeX` input jax (prevents making changes to ``\text{}``,
``\hbox{}``, ``\href{}``, etc.).
* Make `mml2jax` work better with IE namespaces (IE9 no longer seems to
list the ``xmlns`` entries on the ``<html>`` element).

528
docs/html/_static/basic.css
View File

@ -1,528 +0,0 @@
/*
* basic.css
* ~~~~~~~~~
*
* Sphinx stylesheet -- basic theme.
*
* :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
*
*/
/* -- main layout ----------------------------------------------------------- */
div.clearer {
clear: both;
}
/* -- relbar ---------------------------------------------------------------- */
div.related {
width: 100%;
font-size: 90%;
}
div.related h3 {
display: none;
}
div.related ul {
margin: 0;
padding: 0 0 0 10px;
list-style: none;
}
div.related li {
display: inline;
}
div.related li.right {
float: right;
margin-right: 5px;
}
/* -- sidebar --------------------------------------------------------------- */
div.sphinxsidebarwrapper {
padding: 10px 5px 0 10px;
}
div.sphinxsidebar {
float: left;
width: 230px;
margin-left: -100%;
font-size: 90%;
}
div.sphinxsidebar ul {
list-style: none;
}
div.sphinxsidebar ul ul,
div.sphinxsidebar ul.want-points {
margin-left: 20px;
list-style: square;
}
div.sphinxsidebar ul ul {
margin-top: 0;
margin-bottom: 0;
}
div.sphinxsidebar form {
margin-top: 10px;
}
div.sphinxsidebar input {
border: 1px solid #98dbcc;
font-family: sans-serif;
font-size: 1em;
}
img {
border: 0;
}
/* -- search page ----------------------------------------------------------- */
ul.search {
margin: 10px 0 0 20px;
padding: 0;
}
ul.search li {
padding: 5px 0 5px 20px;
background-image: url(file.png);
background-repeat: no-repeat;
background-position: 0 7px;
}
ul.search li a {
font-weight: bold;
}
ul.search li div.context {
color: #888;
margin: 2px 0 0 30px;
text-align: left;
}
ul.keywordmatches li.goodmatch a {
font-weight: bold;
}
/* -- index page ------------------------------------------------------------ */
table.contentstable {
width: 90%;
}
table.contentstable p.biglink {
line-height: 150%;
}
a.biglink {
font-size: 1.3em;
}
span.linkdescr {
font-style: italic;
padding-top: 5px;
font-size: 90%;
}
/* -- general index --------------------------------------------------------- */
table.indextable {
width: 100%;
}
table.indextable td {
text-align: left;
vertical-align: top;
}
table.indextable dl, table.indextable dd {
margin-top: 0;
margin-bottom: 0;
}
table.indextable tr.pcap {
height: 10px;
}
table.indextable tr.cap {
margin-top: 10px;
background-color: #f2f2f2;
}
img.toggler {
margin-right: 3px;
margin-top: 3px;
cursor: pointer;
}
div.modindex-jumpbox {
border-top: 1px solid #ddd;
border-bottom: 1px solid #ddd;
margin: 1em 0 1em 0;
padding: 0.4em;
}
div.genindex-jumpbox {
border-top: 1px solid #ddd;
border-bottom: 1px solid #ddd;
margin: 1em 0 1em 0;
padding: 0.4em;
}
/* -- general body styles --------------------------------------------------- */
a.headerlink {
visibility: hidden;
}
h1:hover > a.headerlink,
h2:hover > a.headerlink,
h3:hover > a.headerlink,
h4:hover > a.headerlink,
h5:hover > a.headerlink,
h6:hover > a.headerlink,
dt:hover > a.headerlink {
visibility: visible;
}
div.body p.caption {
text-align: inherit;
}
div.body td {
text-align: left;
}
.field-list ul {
padding-left: 1em;
}
.first {
margin-top: 0 !important;
}
p.rubric {
margin-top: 30px;
font-weight: bold;
}
img.align-left, .figure.align-left, object.align-left {
clear: left;
float: left;
margin-right: 1em;
}
img.align-right, .figure.align-right, object.align-right {
clear: right;
float: right;
margin-left: 1em;
}
img.align-center, .figure.align-center, object.align-center {
display: block;
margin-left: auto;
margin-right: auto;
}
.align-left {
text-align: left;
}
.align-center {
clear: both;
text-align: center;
}
.align-right {
text-align: right;
}
/* -- sidebars -------------------------------------------------------------- */
div.sidebar {
margin: 0 0 0.5em 1em;
border: 1px solid #ddb;
padding: 7px 7px 0 7px;
background-color: #ffe;
width: 40%;
float: right;
}
p.sidebar-title {
font-weight: bold;
}
/* -- topics ---------------------------------------------------------------- */
div.topic {
border: 1px solid #ccc;
padding: 7px 7px 0 7px;
margin: 10px 0 10px 0;
}
p.topic-title {
font-size: 1.1em;
font-weight: bold;
margin-top: 10px;
}
/* -- admonitions ----------------------------------------------------------- */
div.admonition {
margin-top: 10px;
margin-bottom: 10px;
padding: 7px;
}
div.admonition dt {
font-weight: bold;
}
div.admonition dl {
margin-bottom: 0;
}
p.admonition-title {
margin: 0px 10px 5px 0px;
font-weight: bold;
}
div.body p.centered {
text-align: center;
margin-top: 25px;
}
/* -- tables ---------------------------------------------------------------- */
table.docutils {
border: 0;
border-collapse: collapse;
}
table.docutils td, table.docutils th {
padding: 1px 8px 1px 5px;
border-top: 0;
border-left: 0;
border-right: 0;
border-bottom: 1px solid #aaa;
}
table.field-list td, table.field-list th {
border: 0 !important;
}
table.footnote td, table.footnote th {
border: 0 !important;
}
th {
text-align: left;
padding-right: 5px;
}
table.citation {
border-left: solid 1px gray;
margin-left: 1px;
}
table.citation td {
border-bottom: none;
}
/* -- other body styles ----------------------------------------------------- */
ol.arabic {
list-style: decimal;
}
ol.loweralpha {
list-style: lower-alpha;
}
ol.upperalpha {
list-style: upper-alpha;
}
ol.lowerroman {
list-style: lower-roman;
}
ol.upperroman {
list-style: upper-roman;
}
dl {
margin-bottom: 15px;
}
dd p {
margin-top: 0px;
}
dd ul, dd table {
margin-bottom: 10px;
}
dd {
margin-top: 3px;
margin-bottom: 10px;
margin-left: 30px;
}
dt:target, .highlighted {
background-color: #fbe54e;
}
dl.glossary dt {
font-weight: bold;
font-size: 1.1em;
}
.field-list ul {
margin: 0;
padding-left: 1em;
}
.field-list p {
margin: 0;
}
.refcount {
color: #060;
}
.optional {
font-size: 1.3em;
}
.versionmodified {
font-style: italic;
}
.system-message {
background-color: #fda;
padding: 5px;
border: 3px solid red;
}
.footnote:target {
background-color: #ffa;
}
.line-block {
display: block;
margin-top: 1em;
margin-bottom: 1em;
}
.line-block .line-block {
margin-top: 0;
margin-bottom: 0;
margin-left: 1.5em;
}
.guilabel, .menuselection {
font-family: sans-serif;
}
.accelerator {
text-decoration: underline;
}
.classifier {
font-style: oblique;
}
/* -- code displays --------------------------------------------------------- */
pre {
overflow: auto;
overflow-y: hidden; /* fixes display issues on Chrome browsers */
}
td.linenos pre {
padding: 5px 0px;
border: 0;
background-color: transparent;
color: #aaa;
}
table.highlighttable {
margin-left: 0.5em;
}
table.highlighttable td {
padding: 0 0.5em 0 0.5em;
}
tt.descname {
background-color: transparent;
font-weight: bold;
font-size: 1.2em;
}
tt.descclassname {
background-color: transparent;
}
tt.xref, a tt {
background-color: transparent;
font-weight: bold;
}
h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
background-color: transparent;
}
.viewcode-link {
float: right;
}
.viewcode-back {
float: right;
font-family: sans-serif;
}
div.viewcode-block:target {
margin: -1px -10px;
padding: 0 10px;
}
/* -- math display ---------------------------------------------------------- */
img.math {
vertical-align: middle;
}
div.body div.math p {
text-align: center;
}
span.eqno {
float: right;
}
/* -- printout stylesheet --------------------------------------------------- */
@media print {
div.document,
div.documentwrapper,
div.bodywrapper {
margin: 0 !important;
width: 100%;
}
div.sphinxsidebar,
div.related,
div.footer,
#top-link {
display: none;
}
}

247
docs/html/_static/doctools.js
View File

@ -1,247 +0,0 @@
/*
* doctools.js
* ~~~~~~~~~~~
*
* Sphinx JavaScript utilties for all documentation.
*
* :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
*
*/
/**
* select a different prefix for underscore
*/
$u = _.noConflict();
/**
* make the code below compatible with browsers without
* an installed firebug like debugger
if (!window.console || !console.firebug) {
var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
"dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
"profile", "profileEnd"];
window.console = {};
for (var i = 0; i < names.length; ++i)
window.console[names[i]] = function() {};
}
*/
/**
* small helper function to urldecode strings
*/
jQuery.urldecode = function(x) {
return decodeURIComponent(x).replace(/\+/g, ' ');
}
/**
* small helper function to urlencode strings
*/
jQuery.urlencode = encodeURIComponent;
/**
* This function returns the parsed url parameters of the
* current request. Multiple values per key are supported,
* it will always return arrays of strings for the value parts.
*/
jQuery.getQueryParameters = function(s) {
if (typeof s == 'undefined')
s = document.location.search;
var parts = s.substr(s.indexOf('?') + 1).split('&');
var result = {};
for (var i = 0; i < parts.length; i++) {
var tmp = parts[i].split('=', 2);
var key = jQuery.urldecode(tmp[0]);
var value = jQuery.urldecode(tmp[1]);
if (key in result)
result[key].push(value);
else
result[key] = [value];
}
return result;
};
/**
* small function to check if an array contains
* a given item.
*/
jQuery.contains = function(arr, item) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] == item)
return true;
}
return false;
};
/**
* highlight a given string on a jquery object by wrapping it in
* span elements with the given class name.
*/
jQuery.fn.highlightText = function(text, className) {
function highlight(node) {
if (node.nodeType == 3) {
var val = node.nodeValue;
var pos = val.toLowerCase().indexOf(text);
if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) {
var span = document.createElement("span");
span.className = className;
span.appendChild(document.createTextNode(val.substr(pos, text.length)));
node.parentNode.insertBefore(span, node.parentNode.insertBefore(
document.createTextNode(val.substr(pos + text.length)),
node.nextSibling));
node.nodeValue = val.substr(0, pos);
}
}
else if (!jQuery(node).is("button, select, textarea")) {
jQuery.each(node.childNodes, function() {
highlight(this);
});
}
}
return this.each(function() {
highlight(this);
});
};
/**
* Small JavaScript module for the documentation.
*/
var Documentation = {
init : function() {
this.fixFirefoxAnchorBug();
this.highlightSearchWords();
this.initIndexTable();
},
/**
* i18n support
*/
TRANSLATIONS : {},
PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; },
LOCALE : 'unknown',
// gettext and ngettext don't access this so that the functions
// can safely bound to a different name (_ = Documentation.gettext)
gettext : function(string) {
var translated = Documentation.TRANSLATIONS[string];
if (typeof translated == 'undefined')
return string;
return (typeof translated == 'string') ? translated : translated[0];
},
ngettext : function(singular, plural, n) {
var translated = Documentation.TRANSLATIONS[singular];
if (typeof translated == 'undefined')
return (n == 1) ? singular : plural;
return translated[Documentation.PLURALEXPR(n)];
},
addTranslations : function(catalog) {
for (var key in catalog.messages)
this.TRANSLATIONS[key] = catalog.messages[key];
this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
this.LOCALE = catalog.locale;
},
/**
* add context elements like header anchor links
*/
addContextElements : function() {
$('div[id] > :header:first').each(function() {
$('<a class="headerlink">\u00B6</a>').
attr('href', '#' + this.id).
attr('title', _('Permalink to this headline')).
appendTo(this);
});
$('dt[id]').each(function() {
$('<a class="headerlink">\u00B6</a>').
attr('href', '#' + this.id).
attr('title', _('Permalink to this definition')).
appendTo(this);
});
},
/**
* workaround a firefox stupidity
*/
fixFirefoxAnchorBug : function() {
if (document.location.hash && $.browser.mozilla)
window.setTimeout(function() {
document.location.href += '';
}, 10);
},
/**
* highlight the search words provided in the url in the text
*/
highlightSearchWords : function() {
var params = $.getQueryParameters();
var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
if (terms.length) {
var body = $('div.body');
window.setTimeout(function() {
$.each(terms, function() {
body.highlightText(this.toLowerCase(), 'highlighted');
});
}, 10);
$('<li class="highlight-link"><a href="javascript:Documentation.' +
'hideSearchWords()">' + _('Hide Search Matches') + '</a></li>')
.appendTo($('.sidebar .this-page-menu'));
}
},
/**
* init the domain index toggle buttons
*/
initIndexTable : function() {
var togglers = $('img.toggler').click(function() {
var src = $(this).attr('src');
var idnum = $(this).attr('id').substr(7);
$('tr.cg-' + idnum).toggle();
if (src.substr(-9) == 'minus.png')
$(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
else
$(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
}).css('display', '');
if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
togglers.click();
}
},
/**
* helper function to hide the search marks again
*/
hideSearchWords : function() {
$('.sidebar .this-page-menu li.highlight-link').fadeOut(300);
$('span.highlighted').removeClass('highlighted');
},
/**
* make the url absolute
*/
makeURL : function(relativeURL) {
return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
},
/**
* get the current relative url
*/
getCurrentURL : function() {
var path = document.location.pathname;
var parts = path.split(/\//);
$.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
if (this == '..')
parts.pop();
});
var url = parts.join('/');
return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
}
};
// quick alias for translations
_ = Documentation.gettext;
$(document).ready(function() {
Documentation.init();
});

BIN
docs/html/_static/file.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 392 B

154
docs/html/_static/jquery.js vendored
View File

@ -1,154 +0,0 @@
/*!
* jQuery JavaScript Library v1.4.2
* http://jquery.com/
*
* Copyright 2010, John Resig
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* Includes Sizzle.js
* http://sizzlejs.com/
* Copyright 2010, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
*
* Date: Sat Feb 13 22:33:48 2010 -0500
*/
(function(A,w){function ma(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(ma,1);return}c.ready()}}function Qa(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function X(a,b,d,f,e,j){var i=a.length;if(typeof b==="object"){for(var o in b)X(a,o,b[o],f,e,d);return a}if(d!==w){f=!j&&f&&c.isFunction(d);for(o=0;o<i;o++)e(a[o],b,f?d.call(a[o],o,e(a[o],b)):d,j);return a}return i?
e(a[0],b):w}function J(){return(new Date).getTime()}function Y(){return false}function Z(){return true}function na(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function oa(a){var b,d=[],f=[],e=arguments,j,i,o,k,n,r;i=c.data(this,"events");if(!(a.liveFired===this||!i||!i.live||a.button&&a.type==="click")){a.liveFired=this;var u=i.live.slice(0);for(k=0;k<u.length;k++){i=u[k];i.origType.replace(O,"")===a.type?f.push(i.selector):u.splice(k--,1)}j=c(a.target).closest(f,a.currentTarget);n=0;for(r=
j.length;n<r;n++)for(k=0;k<u.length;k++){i=u[k];if(j[n].selector===i.selector){o=j[n].elem;f=null;if(i.preType==="mouseenter"||i.preType==="mouseleave")f=c(a.relatedTarget).closest(i.selector)[0];if(!f||f!==o)d.push({elem:o,handleObj:i})}}n=0;for(r=d.length;n<r;n++){j=d[n];a.currentTarget=j.elem;a.data=j.handleObj.data;a.handleObj=j.handleObj;if(j.handleObj.origHandler.apply(j.elem,e)===false){b=false;break}}return b}}function pa(a,b){return"live."+(a&&a!=="*"?a+".":"")+b.replace(/\./g,"`").replace(/ /g,
"&")}function qa(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function ra(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var f=c.data(a[d++]),e=c.data(this,f);if(f=f&&f.events){delete e.handle;e.events={};for(var j in f)for(var i in f[j])c.event.add(this,j,f[j][i],f[j][i].data)}}})}function sa(a,b,d){var f,e,j;b=b&&b[0]?b[0].ownerDocument||b[0]:s;if(a.length===1&&typeof a[0]==="string"&&a[0].length<512&&b===s&&!ta.test(a[0])&&(c.support.checkClone||!ua.test(a[0]))){e=
true;if(j=c.fragments[a[0]])if(j!==1)f=j}if(!f){f=b.createDocumentFragment();c.clean(a,b,f,d)}if(e)c.fragments[a[0]]=j?f:1;return{fragment:f,cacheable:e}}function K(a,b){var d={};c.each(va.concat.apply([],va.slice(0,b)),function(){d[this]=a});return d}function wa(a){return"scrollTo"in a&&a.document?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var c=function(a,b){return new c.fn.init(a,b)},Ra=A.jQuery,Sa=A.$,s=A.document,T,Ta=/^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,Ua=/^.[^:#\[\.,]*$/,Va=/\S/,
Wa=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Xa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],L,$=Object.prototype.toString,aa=Object.prototype.hasOwnProperty,ba=Array.prototype.push,R=Array.prototype.slice,ya=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(a==="body"&&!b){this.context=s;this[0]=s.body;this.selector="body";this.length=1;return this}if(typeof a==="string")if((d=Ta.exec(a))&&
(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Xa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=sa([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}return c.merge(this,a)}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return T.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a);return c.merge(this,
a)}else return!b||b.jquery?(b||T).find(a):c(b).find(a);else if(c.isFunction(a))return T.ready(a);if(a.selector!==w){this.selector=a.selector;this.context=a.context}return c.makeArray(a,this)},selector:"",jquery:"1.4.2",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){var f=c();c.isArray(a)?ba.apply(f,a):c.merge(f,a);f.prevObject=this;f.context=this.context;if(b===
"find")f.selector=this.selector+(this.selector?" ":"")+d;else if(b)f.selector=this.selector+"."+b+"("+d+")";return f},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this,
function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||c(null)},push:ba,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,j,i,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b<d;b++)if((e=arguments[b])!=null)for(j in e){i=a[j];o=e[j];if(a!==o)if(f&&o&&(c.isPlainObject(o)||c.isArray(o))){i=i&&(c.isPlainObject(i)||
c.isArray(i))?i:c.isArray(o)?[]:{};a[j]=c.extend(f,i,o)}else if(o!==w)a[j]=o}return a};c.extend({noConflict:function(a){A.$=Sa;if(a)A.jQuery=Ra;return c},isReady:false,ready:function(){if(!c.isReady){if(!s.body)return setTimeout(c.ready,13);c.isReady=true;if(Q){for(var a,b=0;a=Q[b++];)a.call(s,c);Q=null}c.fn.triggerHandler&&c(s).triggerHandler("ready")}},bindReady:function(){if(!xa){xa=true;if(s.readyState==="complete")return c.ready();if(s.addEventListener){s.addEventListener("DOMContentLoaded",
L,false);A.addEventListener("load",c.ready,false)}else if(s.attachEvent){s.attachEvent("onreadystatechange",L);A.attachEvent("onload",c.ready);var a=false;try{a=A.frameElement==null}catch(b){}s.documentElement.doScroll&&a&&ma()}}},isFunction:function(a){return $.call(a)==="[object Function]"},isArray:function(a){return $.call(a)==="[object Array]"},isPlainObject:function(a){if(!a||$.call(a)!=="[object Object]"||a.nodeType||a.setInterval)return false;if(a.constructor&&!aa.call(a,"constructor")&&!aa.call(a.constructor.prototype,
"isPrototypeOf"))return false;var b;for(b in a);return b===w||aa.call(a,b)},isEmptyObject:function(a){for(var b in a)return false;return true},error:function(a){throw a;},parseJSON:function(a){if(typeof a!=="string"||!a)return null;a=c.trim(a);if(/^[\],:{}\s]*$/.test(a.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"")))return A.JSON&&A.JSON.parse?A.JSON.parse(a):(new Function("return "+
a))();else c.error("Invalid JSON: "+a)},noop:function(){},globalEval:function(a){if(a&&Va.test(a)){var b=s.getElementsByTagName("head")[0]||s.documentElement,d=s.createElement("script");d.type="text/javascript";if(c.support.scriptEval)d.appendChild(s.createTextNode(a));else d.text=a;b.insertBefore(d,b.firstChild);b.removeChild(d)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,b,d){var f,e=0,j=a.length,i=j===w||c.isFunction(a);if(d)if(i)for(f in a){if(b.apply(a[f],
d)===false)break}else for(;e<j;){if(b.apply(a[e++],d)===false)break}else if(i)for(f in a){if(b.call(a[f],f,a[f])===false)break}else for(d=a[0];e<j&&b.call(d,e,d)!==false;d=a[++e]);return a},trim:function(a){return(a||"").replace(Wa,"")},makeArray:function(a,b){b=b||[];if(a!=null)a.length==null||typeof a==="string"||c.isFunction(a)||typeof a!=="function"&&a.setInterval?ba.call(b,a):c.merge(b,a);return b},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var d=0,f=b.length;d<f;d++)if(b[d]===
a)return d;return-1},merge:function(a,b){var d=a.length,f=0;if(typeof b.length==="number")for(var e=b.length;f<e;f++)a[d++]=b[f];else for(;b[f]!==w;)a[d++]=b[f++];a.length=d;return a},grep:function(a,b,d){for(var f=[],e=0,j=a.length;e<j;e++)!d!==!b(a[e],e)&&f.push(a[e]);return f},map:function(a,b,d){for(var f=[],e,j=0,i=a.length;j<i;j++){e=b(a[j],j,d);if(e!=null)f[f.length]=e}return f.concat.apply([],f)},guid:1,proxy:function(a,b,d){if(arguments.length===2)if(typeof b==="string"){d=a;a=d[b];b=w}else if(b&&
!c.isFunction(b)){d=b;b=w}if(!b&&a)b=function(){return a.apply(d||this,arguments)};if(a)b.guid=a.guid=a.guid||b.guid||c.guid++;return b},uaMatch:function(a){a=a.toLowerCase();a=/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version)?[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||!/compatible/.test(a)&&/(mozilla)(?:.*? rv:([\w.]+))?/.exec(a)||[];return{browser:a[1]||"",version:a[2]||"0"}},browser:{}});P=c.uaMatch(P);if(P.browser){c.browser[P.browser]=true;c.browser.version=P.version}if(c.browser.webkit)c.browser.safari=
true;if(ya)c.inArray=function(a,b){return ya.call(b,a)};T=c(s);if(s.addEventListener)L=function(){s.removeEventListener("DOMContentLoaded",L,false);c.ready()};else if(s.attachEvent)L=function(){if(s.readyState==="complete"){s.detachEvent("onreadystatechange",L);c.ready()}};(function(){c.support={};var a=s.documentElement,b=s.createElement("script"),d=s.createElement("div"),f="script"+J();d.style.display="none";d.innerHTML=" <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
var e=d.getElementsByTagName("*"),j=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!j)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(j.getAttribute("style")),hrefNormalized:j.getAttribute("href")==="/a",opacity:/^0.55$/.test(j.style.opacity),cssFloat:!!j.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected,
parentNode:d.removeChild(d.appendChild(s.createElement("div"))).parentNode===null,deleteExpando:true,checkClone:false,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(i){}a.insertBefore(b,a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}try{delete b.test}catch(o){c.support.deleteExpando=false}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function k(){c.support.noCloneEvent=
false;d.detachEvent("onclick",k)});d.cloneNode(true).fireEvent("onclick")}d=s.createElement("div");d.innerHTML="<input type='radio' name='radiotest' checked='checked'/>";a=s.createDocumentFragment();a.appendChild(d.firstChild);c.support.checkClone=a.cloneNode(true).cloneNode(true).lastChild.checked;c(function(){var k=s.createElement("div");k.style.width=k.style.paddingLeft="1px";s.body.appendChild(k);c.boxModel=c.support.boxModel=k.offsetWidth===2;s.body.removeChild(k).style.display="none"});a=function(k){var n=
s.createElement("div");k="on"+k;var r=k in n;if(!r){n.setAttribute(k,"return;");r=typeof n[k]==="function"}return r};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=j=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var G="jQuery"+J(),Ya=0,za={};c.extend({cache:{},expando:G,noData:{embed:true,object:true,
applet:true},data:function(a,b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var f=a[G],e=c.cache;if(!f&&typeof b==="string"&&d===w)return null;f||(f=++Ya);if(typeof b==="object"){a[G]=f;e[f]=c.extend(true,{},b)}else if(!e[f]){a[G]=f;e[f]={}}a=e[f];if(d!==w)a[b]=d;return typeof b==="string"?a[b]:a}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var d=a[G],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{if(c.support.deleteExpando)delete a[c.expando];
else a.removeAttribute&&a.removeAttribute(c.expando);delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this,
a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b===
w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var Aa=/[\n\t]/g,ca=/\s+/,Za=/\r/g,$a=/href|src|style/,ab=/(button|input)/i,bb=/(button|input|object|select|textarea)/i,
cb=/^(a|area)$/i,Ba=/radio|checkbox/;c.fn.extend({attr:function(a,b){return X(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(n){var r=c(this);r.addClass(a.call(this,n,r.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1)if(e.className){for(var j=" "+e.className+" ",
i=e.className,o=0,k=b.length;o<k;o++)if(j.indexOf(" "+b[o]+" ")<0)i+=" "+b[o];e.className=c.trim(i)}else e.className=a}return this},removeClass:function(a){if(c.isFunction(a))return this.each(function(k){var n=c(this);n.removeClass(a.call(this,k,n.attr("class")))});if(a&&typeof a==="string"||a===w)for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1&&e.className)if(a){for(var j=(" "+e.className+" ").replace(Aa," "),i=0,o=b.length;i<o;i++)j=j.replace(" "+b[i]+" ",
" ");e.className=c.trim(j)}else e.className=""}return this},toggleClass:function(a,b){var d=typeof a,f=typeof b==="boolean";if(c.isFunction(a))return this.each(function(e){var j=c(this);j.toggleClass(a.call(this,e,j.attr("class"),b),b)});return this.each(function(){if(d==="string")for(var e,j=0,i=c(this),o=b,k=a.split(ca);e=k[j++];){o=f?o:!i.hasClass(e);i[o?"addClass":"removeClass"](e)}else if(d==="undefined"||d==="boolean"){this.className&&c.data(this,"__className__",this.className);this.className=
this.className||a===false?"":c.data(this,"__className__")||""}})},hasClass:function(a){a=" "+a+" ";for(var b=0,d=this.length;b<d;b++)if((" "+this[b].className+" ").replace(Aa," ").indexOf(a)>-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var j=b?d:0;for(d=b?d+1:e.length;j<d;j++){var i=
e[j];if(i.selected){a=c(i).val();if(b)return a;f.push(a)}}return f}if(Ba.test(b.type)&&!c.support.checkOn)return b.getAttribute("value")===null?"on":b.value;return(b.value||"").replace(Za,"")}return w}var o=c.isFunction(a);return this.each(function(k){var n=c(this),r=a;if(this.nodeType===1){if(o)r=a.call(this,k,n.val());if(typeof r==="number")r+="";if(c.isArray(r)&&Ba.test(this.type))this.checked=c.inArray(n.val(),r)>=0;else if(c.nodeName(this,"select")){var u=c.makeArray(r);c("option",this).each(function(){this.selected=
c.inArray(c(this).val(),u)>=0});if(!u.length)this.selectedIndex=-1}else this.value=r}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var j=$a.test(b);if(b in a&&f&&!j){if(e){b==="type"&&ab.test(a.nodeName)&&a.parentNode&&c.error("type property can't be changed");
a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:bb.test(a.nodeName)||cb.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&j?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var O=/\.(.*)$/,db=function(a){return a.replace(/[^\w\s\.\|`]/g,
function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;var e,j;if(d.handler){e=d;d=e.handler}if(!d.guid)d.guid=c.guid++;if(j=c.data(a)){var i=j.events=j.events||{},o=j.handle;if(!o)j.handle=o=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(o.elem,arguments):w};o.elem=a;b=b.split(" ");for(var k,n=0,r;k=b[n++];){j=e?c.extend({},e):{handler:d,data:f};if(k.indexOf(".")>-1){r=k.split(".");
k=r.shift();j.namespace=r.slice(0).sort().join(".")}else{r=[];j.namespace=""}j.type=k;j.guid=d.guid;var u=i[k],z=c.event.special[k]||{};if(!u){u=i[k]=[];if(!z.setup||z.setup.call(a,f,r,o)===false)if(a.addEventListener)a.addEventListener(k,o,false);else a.attachEvent&&a.attachEvent("on"+k,o)}if(z.add){z.add.call(a,j);if(!j.handler.guid)j.handler.guid=d.guid}u.push(j);c.event.global[k]=true}a=null}}},global:{},remove:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){var e,j=0,i,o,k,n,r,u,z=c.data(a),
C=z&&z.events;if(z&&C){if(b&&b.type){d=b.handler;b=b.type}if(!b||typeof b==="string"&&b.charAt(0)==="."){b=b||"";for(e in C)c.event.remove(a,e+b)}else{for(b=b.split(" ");e=b[j++];){n=e;i=e.indexOf(".")<0;o=[];if(!i){o=e.split(".");e=o.shift();k=new RegExp("(^|\\.)"+c.map(o.slice(0).sort(),db).join("\\.(?:.*\\.)?")+"(\\.|$)")}if(r=C[e])if(d){n=c.event.special[e]||{};for(B=f||0;B<r.length;B++){u=r[B];if(d.guid===u.guid){if(i||k.test(u.namespace)){f==null&&r.splice(B--,1);n.remove&&n.remove.call(a,u)}if(f!=
null)break}}if(r.length===0||f!=null&&r.length===1){if(!n.teardown||n.teardown.call(a,o)===false)Ca(a,e,z.handle);delete C[e]}}else for(var B=0;B<r.length;B++){u=r[B];if(i||k.test(u.namespace)){c.event.remove(a,n,u.handler,B);r.splice(B--,1)}}}if(c.isEmptyObject(C)){if(b=z.handle)b.elem=null;delete z.events;delete z.handle;c.isEmptyObject(z)&&c.removeData(a)}}}}},trigger:function(a,b,d,f){var e=a.type||a;if(!f){a=typeof a==="object"?a[G]?a:c.extend(c.Event(e),a):c.Event(e);if(e.indexOf("!")>=0){a.type=
e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();c.event.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;(f=c.data(d,"handle"))&&f.apply(d,b);f=d.parentNode||d.ownerDocument;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()]))if(d["on"+e]&&d["on"+e].apply(d,b)===false)a.result=false}catch(j){}if(!a.isPropagationStopped()&&
f)c.event.trigger(a,b,f,true);else if(!a.isDefaultPrevented()){f=a.target;var i,o=c.nodeName(f,"a")&&e==="click",k=c.event.special[e]||{};if((!k._default||k._default.call(d,a)===false)&&!o&&!(f&&f.nodeName&&c.noData[f.nodeName.toLowerCase()])){try{if(f[e]){if(i=f["on"+e])f["on"+e]=null;c.event.triggered=true;f[e]()}}catch(n){}if(i)f["on"+e]=i;c.event.triggered=false}}},handle:function(a){var b,d,f,e;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;b=a.type.indexOf(".")<0&&!a.exclusive;
if(!b){d=a.type.split(".");a.type=d.shift();f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)")}e=c.data(this,"events");d=e[a.type];if(e&&d){d=d.slice(0);e=0;for(var j=d.length;e<j;e++){var i=d[e];if(b||f.test(i.namespace)){a.handler=i.handler;a.data=i.data;a.handleObj=i;i=i.handler.apply(this,arguments);if(i!==w){a.result=i;if(i===false){a.preventDefault();a.stopPropagation()}}if(a.isImmediatePropagationStopped())break}}}return a.result},props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
fix:function(a){if(a[G])return a;var b=a;a=c.Event(b);for(var d=this.props.length,f;d;){f=this.props[--d];a[f]=b[f]}if(!a.target)a.target=a.srcElement||s;if(a.target.nodeType===3)a.target=a.target.parentNode;if(!a.relatedTarget&&a.fromElement)a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement;if(a.pageX==null&&a.clientX!=null){b=s.documentElement;d=s.body;a.pageX=a.clientX+(b&&b.scrollLeft||d&&d.scrollLeft||0)-(b&&b.clientLeft||d&&d.clientLeft||0);a.pageY=a.clientY+(b&&b.scrollTop||
d&&d.scrollTop||0)-(b&&b.clientTop||d&&d.clientTop||0)}if(!a.which&&(a.charCode||a.charCode===0?a.charCode:a.keyCode))a.which=a.charCode||a.keyCode;if(!a.metaKey&&a.ctrlKey)a.metaKey=a.ctrlKey;if(!a.which&&a.button!==w)a.which=a.button&1?1:a.button&2?3:a.button&4?2:0;return a},guid:1E8,proxy:c.proxy,special:{ready:{setup:c.bindReady,teardown:c.noop},live:{add:function(a){c.event.add(this,a.origType,c.extend({},a,{handler:oa}))},remove:function(a){var b=true,d=a.origType.replace(O,"");c.each(c.data(this,
"events").live||[],function(){if(d===this.origType.replace(O,""))return b=false});b&&c.event.remove(this,a.origType,oa)}},beforeunload:{setup:function(a,b,d){if(this.setInterval)this.onbeforeunload=d;return false},teardown:function(a,b){if(this.onbeforeunload===b)this.onbeforeunload=null}}}};var Ca=s.removeEventListener?function(a,b,d){a.removeEventListener(b,d,false)}:function(a,b,d){a.detachEvent("on"+b,d)};c.Event=function(a){if(!this.preventDefault)return new c.Event(a);if(a&&a.type){this.originalEvent=
a;this.type=a.type}else this.type=a;this.timeStamp=J();this[G]=true};c.Event.prototype={preventDefault:function(){this.isDefaultPrevented=Z;var a=this.originalEvent;if(a){a.preventDefault&&a.preventDefault();a.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=Z;var a=this.originalEvent;if(a){a.stopPropagation&&a.stopPropagation();a.cancelBubble=true}},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=Z;this.stopPropagation()},isDefaultPrevented:Y,isPropagationStopped:Y,
isImmediatePropagationStopped:Y};var Da=function(a){var b=a.relatedTarget;try{for(;b&&b!==this;)b=b.parentNode;if(b!==this){a.type=a.data;c.event.handle.apply(this,arguments)}}catch(d){}},Ea=function(a){a.type=a.data;c.event.handle.apply(this,arguments)};c.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){c.event.special[a]={setup:function(d){c.event.add(this,b,d&&d.selector?Ea:Da,a)},teardown:function(d){c.event.remove(this,b,d&&d.selector?Ea:Da)}}});if(!c.support.submitBubbles)c.event.special.submit=
{setup:function(){if(this.nodeName.toLowerCase()!=="form"){c.event.add(this,"click.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="submit"||d==="image")&&c(b).closest("form").length)return na("submit",this,arguments)});c.event.add(this,"keypress.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="text"||d==="password")&&c(b).closest("form").length&&a.keyCode===13)return na("submit",this,arguments)})}else return false},teardown:function(){c.event.remove(this,".specialSubmit")}};
if(!c.support.changeBubbles){var da=/textarea|input|select/i,ea,Fa=function(a){var b=a.type,d=a.value;if(b==="radio"||b==="checkbox")d=a.checked;else if(b==="select-multiple")d=a.selectedIndex>-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d},fa=function(a,b){var d=a.target,f,e;if(!(!da.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Fa(d);if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data",
e);if(!(f===w||e===f))if(f!=null||e){a.type="change";return c.event.trigger(a,b,d)}}};c.event.special.change={filters:{focusout:fa,click:function(a){var b=a.target,d=b.type;if(d==="radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return fa.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return fa.call(this,a)},beforeactivate:function(a){a=a.target;c.data(a,
"_change_data",Fa(a))}},setup:function(){if(this.type==="file")return false;for(var a in ea)c.event.add(this,a+".specialChange",ea[a]);return da.test(this.nodeName)},teardown:function(){c.event.remove(this,".specialChange");return da.test(this.nodeName)}};ea=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a,
d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,f,e){if(typeof d==="object"){for(var j in d)this[b](j,f,d[j],e);return this}if(c.isFunction(f)){e=f;f=w}var i=b==="one"?c.proxy(e,function(k){c(this).unbind(k,i);return e.apply(this,arguments)}):e;if(d==="unload"&&b!=="one")this.one(d,f,e);else{j=0;for(var o=this.length;j<o;j++)c.event.add(this[j],d,i,f)}return this}});c.fn.extend({unbind:function(a,b){if(typeof a==="object"&&
!a.preventDefault)for(var d in a)this.unbind(d,a[d]);else{d=0;for(var f=this.length;d<f;d++)c.event.remove(this[d],a,b)}return this},delegate:function(a,b,d,f){return this.live(b,d,f,a)},undelegate:function(a,b,d){return arguments.length===0?this.unbind("live"):this.die(b,null,d,a)},trigger:function(a,b){return this.each(function(){c.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){a=c.Event(a);a.preventDefault();a.stopPropagation();c.event.trigger(a,b,this[0]);return a.result}},
toggle:function(a){for(var b=arguments,d=1;d<b.length;)c.proxy(a,b[d++]);return this.click(c.proxy(a,function(f){var e=(c.data(this,"lastToggle"+a.guid)||0)%d;c.data(this,"lastToggle"+a.guid,e+1);f.preventDefault();return b[e].apply(this,arguments)||false}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var Ga={focus:"focusin",blur:"focusout",mouseenter:"mouseover",mouseleave:"mouseout"};c.each(["live","die"],function(a,b){c.fn[b]=function(d,f,e,j){var i,o=0,k,n,r=j||this.selector,
u=j?this:c(this.context);if(c.isFunction(f)){e=f;f=w}for(d=(d||"").split(" ");(i=d[o++])!=null;){j=O.exec(i);k="";if(j){k=j[0];i=i.replace(O,"")}if(i==="hover")d.push("mouseenter"+k,"mouseleave"+k);else{n=i;if(i==="focus"||i==="blur"){d.push(Ga[i]+k);i+=k}else i=(Ga[i]||i)+k;b==="live"?u.each(function(){c.event.add(this,pa(i,r),{data:f,selector:r,handler:e,origType:i,origHandler:e,preType:n})}):u.unbind(pa(i,r),e)}}return this}});c.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),
function(a,b){c.fn[b]=function(d){return d?this.bind(b,d):this.trigger(b)};if(c.attrFn)c.attrFn[b]=true});A.attachEvent&&!A.addEventListener&&A.attachEvent("onunload",function(){for(var a in c.cache)if(c.cache[a].handle)try{c.event.remove(c.cache[a].handle.elem)}catch(b){}});(function(){function a(g){for(var h="",l,m=0;g[m];m++){l=g[m];if(l.nodeType===3||l.nodeType===4)h+=l.nodeValue;else if(l.nodeType!==8)h+=a(l.childNodes)}return h}function b(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];
if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1&&!p){t.sizcache=l;t.sizset=q}if(t.nodeName.toLowerCase()===h){y=t;break}t=t[g]}m[q]=y}}}function d(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1){if(!p){t.sizcache=l;t.sizset=q}if(typeof h!=="string"){if(t===h){y=true;break}}else if(k.filter(h,[t]).length>0){y=t;break}}t=t[g]}m[q]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
e=0,j=Object.prototype.toString,i=false,o=true;[0,0].sort(function(){o=false;return 0});var k=function(g,h,l,m){l=l||[];var q=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return l;for(var p=[],v,t,y,S,H=true,M=x(h),I=g;(f.exec(""),v=f.exec(I))!==null;){I=v[3];p.push(v[1]);if(v[2]){S=v[3];break}}if(p.length>1&&r.exec(g))if(p.length===2&&n.relative[p[0]])t=ga(p[0]+p[1],h);else for(t=n.relative[p[0]]?[h]:k(p.shift(),h);p.length;){g=p.shift();if(n.relative[g])g+=p.shift();
t=ga(g,t)}else{if(!m&&p.length>1&&h.nodeType===9&&!M&&n.match.ID.test(p[0])&&!n.match.ID.test(p[p.length-1])){v=k.find(p.shift(),h,M);h=v.expr?k.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:p.pop(),set:z(m)}:k.find(p.pop(),p.length===1&&(p[0]==="~"||p[0]==="+")&&h.parentNode?h.parentNode:h,M);t=v.expr?k.filter(v.expr,v.set):v.set;if(p.length>0)y=z(t);else H=false;for(;p.length;){var D=p.pop();v=D;if(n.relative[D])v=p.pop();else D="";if(v==null)v=h;n.relative[D](y,v,M)}}else y=[]}y||(y=t);y||k.error(D||
g);if(j.call(y)==="[object Array]")if(H)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&E(h,y[g])))l.push(t[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&l.push(t[g]);else l.push.apply(l,y);else z(y,l);if(S){k(S,q,l,m);k.uniqueSort(l)}return l};k.uniqueSort=function(g){if(B){i=o;g.sort(B);if(i)for(var h=1;h<g.length;h++)g[h]===g[h-1]&&g.splice(h--,1)}return g};k.matches=function(g,h){return k(g,null,null,h)};k.find=function(g,h,l){var m,q;if(!g)return[];
for(var p=0,v=n.order.length;p<v;p++){var t=n.order[p];if(q=n.leftMatch[t].exec(g)){var y=q[1];q.splice(1,1);if(y.substr(y.length-1)!=="\\"){q[1]=(q[1]||"").replace(/\\/g,"");m=n.find[t](q,h,l);if(m!=null){g=g.replace(n.match[t],"");break}}}}m||(m=h.getElementsByTagName("*"));return{set:m,expr:g}};k.filter=function(g,h,l,m){for(var q=g,p=[],v=h,t,y,S=h&&h[0]&&x(h[0]);g&&h.length;){for(var H in n.filter)if((t=n.leftMatch[H].exec(g))!=null&&t[2]){var M=n.filter[H],I,D;D=t[1];y=false;t.splice(1,1);if(D.substr(D.length-
1)!=="\\"){if(v===p)p=[];if(n.preFilter[H])if(t=n.preFilter[H](t,v,l,p,m,S)){if(t===true)continue}else y=I=true;if(t)for(var U=0;(D=v[U])!=null;U++)if(D){I=M(D,t,U,v);var Ha=m^!!I;if(l&&I!=null)if(Ha)y=true;else v[U]=false;else if(Ha){p.push(D);y=true}}if(I!==w){l||(v=p);g=g.replace(n.match[H],"");if(!y)return[];break}}}if(g===q)if(y==null)k.error(g);else break;q=g}return v};k.error=function(g){throw"Syntax error, unrecognized expression: "+g;};var n=k.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
CLASS:/\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(g){return g.getAttribute("href")}},
relative:{"+":function(g,h){var l=typeof h==="string",m=l&&!/\W/.test(h);l=l&&!m;if(m)h=h.toLowerCase();m=0;for(var q=g.length,p;m<q;m++)if(p=g[m]){for(;(p=p.previousSibling)&&p.nodeType!==1;);g[m]=l||p&&p.nodeName.toLowerCase()===h?p||false:p===h}l&&k.filter(h,g,true)},">":function(g,h){var l=typeof h==="string";if(l&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,q=g.length;m<q;m++){var p=g[m];if(p){l=p.parentNode;g[m]=l.nodeName.toLowerCase()===h?l:false}}}else{m=0;for(q=g.length;m<q;m++)if(p=g[m])g[m]=
l?p.parentNode:p.parentNode===h;l&&k.filter(h,g,true)}},"":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("parentNode",h,m,g,p,l)},"~":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("previousSibling",h,m,g,p,l)}},find:{ID:function(g,h,l){if(typeof h.getElementById!=="undefined"&&!l)return(g=h.getElementById(g[1]))?[g]:[]},NAME:function(g,h){if(typeof h.getElementsByName!=="undefined"){var l=[];
h=h.getElementsByName(g[1]);for(var m=0,q=h.length;m<q;m++)h[m].getAttribute("name")===g[1]&&l.push(h[m]);return l.length===0?null:l}},TAG:function(g,h){return h.getElementsByTagName(g[1])}},preFilter:{CLASS:function(g,h,l,m,q,p){g=" "+g[1].replace(/\\/g,"")+" ";if(p)return g;p=0;for(var v;(v=h[p])!=null;p++)if(v)if(q^(v.className&&(" "+v.className+" ").replace(/[\t\n]/g," ").indexOf(g)>=0))l||m.push(v);else if(l)h[p]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()},
CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,l,m,q,p){h=g[1].replace(/\\/g,"");if(!p&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,l,m,q){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=k(g[3],null,null,h);else{g=k.filter(g[3],h,l,true^q);l||m.push.apply(m,
g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,l){return!!k(l[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)},
text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}},
setFilters:{first:function(g,h){return h===0},last:function(g,h,l,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,l){return h<l[3]-0},gt:function(g,h,l){return h>l[3]-0},nth:function(g,h,l){return l[3]-0===h},eq:function(g,h,l){return l[3]-0===h}},filter:{PSEUDO:function(g,h,l,m){var q=h[1],p=n.filters[q];if(p)return p(g,l,h,m);else if(q==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(q==="not"){h=
h[3];l=0;for(m=h.length;l<m;l++)if(h[l]===g)return false;return true}else k.error("Syntax error, unrecognized expression: "+q)},CHILD:function(g,h){var l=h[1],m=g;switch(l){case "only":case "first":for(;m=m.previousSibling;)if(m.nodeType===1)return false;if(l==="first")return true;m=g;case "last":for(;m=m.nextSibling;)if(m.nodeType===1)return false;return true;case "nth":l=h[2];var q=h[3];if(l===1&&q===0)return true;h=h[0];var p=g.parentNode;if(p&&(p.sizcache!==h||!g.nodeIndex)){var v=0;for(m=p.firstChild;m;m=
m.nextSibling)if(m.nodeType===1)m.nodeIndex=++v;p.sizcache=h}g=g.nodeIndex-q;return l===0?g===0:g%l===0&&g/l>=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var l=h[1];g=n.attrHandle[l]?n.attrHandle[l](g):g[l]!=null?g[l]:g.getAttribute(l);l=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m===
"="?l===h:m==="*="?l.indexOf(h)>=0:m==="~="?(" "+l+" ").indexOf(h)>=0:!h?l&&g!==false:m==="!="?l!==h:m==="^="?l.indexOf(h)===0:m==="$="?l.substr(l.length-h.length)===h:m==="|="?l===h||l.substr(0,h.length+1)===h+"-":false},POS:function(g,h,l,m){var q=n.setFilters[h[2]];if(q)return q(g,l,h,m)}}},r=n.match.POS;for(var u in n.match){n.match[u]=new RegExp(n.match[u].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[u]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[u].source.replace(/\\(\d+)/g,function(g,
h){return"\\"+(h-0+1)}))}var z=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){z=function(g,h){h=h||[];if(j.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var l=0,m=g.length;l<m;l++)h.push(g[l]);else for(l=0;g[l];l++)h.push(g[l]);return h}}var B;if(s.documentElement.compareDocumentPosition)B=function(g,h){if(!g.compareDocumentPosition||
!h.compareDocumentPosition){if(g==h)i=true;return g.compareDocumentPosition?-1:1}g=g.compareDocumentPosition(h)&4?-1:g===h?0:1;if(g===0)i=true;return g};else if("sourceIndex"in s.documentElement)B=function(g,h){if(!g.sourceIndex||!h.sourceIndex){if(g==h)i=true;return g.sourceIndex?-1:1}g=g.sourceIndex-h.sourceIndex;if(g===0)i=true;return g};else if(s.createRange)B=function(g,h){if(!g.ownerDocument||!h.ownerDocument){if(g==h)i=true;return g.ownerDocument?-1:1}var l=g.ownerDocument.createRange(),m=
h.ownerDocument.createRange();l.setStart(g,0);l.setEnd(g,0);m.setStart(h,0);m.setEnd(h,0);g=l.compareBoundaryPoints(Range.START_TO_END,m);if(g===0)i=true;return g};(function(){var g=s.createElement("div"),h="script"+(new Date).getTime();g.innerHTML="<a name='"+h+"'/>";var l=s.documentElement;l.insertBefore(g,l.firstChild);if(s.getElementById(h)){n.find.ID=function(m,q,p){if(typeof q.getElementById!=="undefined"&&!p)return(q=q.getElementById(m[1]))?q.id===m[1]||typeof q.getAttributeNode!=="undefined"&&
q.getAttributeNode("id").nodeValue===m[1]?[q]:w:[]};n.filter.ID=function(m,q){var p=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&p&&p.nodeValue===q}}l.removeChild(g);l=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,l){l=l.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;l[m];m++)l[m].nodeType===1&&h.push(l[m]);l=h}return l};g.innerHTML="<a href='#'></a>";
if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=k,h=s.createElement("div");h.innerHTML="<p class='TEST'></p>";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){k=function(m,q,p,v){q=q||s;if(!v&&q.nodeType===9&&!x(q))try{return z(q.querySelectorAll(m),p)}catch(t){}return g(m,q,p,v)};for(var l in g)k[l]=g[l];h=null}}();
(function(){var g=s.createElement("div");g.innerHTML="<div class='test e'></div><div class='test'></div>";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,l,m){if(typeof l.getElementsByClassName!=="undefined"&&!m)return l.getElementsByClassName(h[1])};g=null}}})();var E=s.compareDocumentPosition?function(g,h){return!!(g.compareDocumentPosition(h)&16)}:
function(g,h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ga=function(g,h){var l=[],m="",q;for(h=h.nodeType?[h]:h;q=n.match.PSEUDO.exec(g);){m+=q[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;q=0;for(var p=h.length;q<p;q++)k(g,h[q],l);return k.filter(m,l)};c.find=k;c.expr=k.selectors;c.expr[":"]=c.expr.filters;c.unique=k.uniqueSort;c.text=a;c.isXMLDoc=x;c.contains=E})();var eb=/Until$/,fb=/^(?:parents|prevUntil|prevAll)/,
gb=/,/;R=Array.prototype.slice;var Ia=function(a,b,d){if(c.isFunction(b))return c.grep(a,function(e,j){return!!b.call(e,j,e)===d});else if(b.nodeType)return c.grep(a,function(e){return e===b===d});else if(typeof b==="string"){var f=c.grep(a,function(e){return e.nodeType===1});if(Ua.test(b))return c.filter(b,f,!d);else b=c.filter(b,f)}return c.grep(a,function(e){return c.inArray(e,b)>=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f<e;f++){d=b.length;
c.find(a,this[f],b);if(f>0)for(var j=d;j<b.length;j++)for(var i=0;i<d;i++)if(b[i]===b[j]){b.splice(j--,1);break}}return b},has:function(a){var b=c(a);return this.filter(function(){for(var d=0,f=b.length;d<f;d++)if(c.contains(this,b[d]))return true})},not:function(a){return this.pushStack(Ia(this,a,false),"not",a)},filter:function(a){return this.pushStack(Ia(this,a,true),"filter",a)},is:function(a){return!!a&&c.filter(a,this).length>0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,j=
{},i;if(f&&a.length){e=0;for(var o=a.length;e<o;e++){i=a[e];j[i]||(j[i]=c.expr.match.POS.test(i)?c(i,b||this.context):i)}for(;f&&f.ownerDocument&&f!==b;){for(i in j){e=j[i];if(e.jquery?e.index(f)>-1:c(f).is(e)){d.push({selector:i,elem:f});delete j[i]}}f=f.parentNode}}return d}var k=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,r){for(;r&&r.ownerDocument&&r!==b;){if(k?k.index(r)>-1:c(r).is(a))return r;r=r.parentNode}return null})},index:function(a){if(!a||typeof a===
"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(qa(a[0])||qa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode",
d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")?
a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);eb.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||gb.test(f))&&fb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||a.nodeType!==1||!c(a).is(d));){a.nodeType===
1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ja=/ jQuery\d+="(?:\d+|null)"/g,V=/^\s+/,Ka=/(<([\w:]+)[^>]*?)\/>/g,hb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,La=/<([\w:]+)/,ib=/<tbody/i,jb=/<|&#?\w+;/,ta=/<script|<object|<embed|<option|<style/i,ua=/checked\s*(?:[^=]|=\s*.checked.)/i,Ma=function(a,b,d){return hb.test(d)?
a:b+"></"+d+">"},F={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};F.optgroup=F.option;F.tbody=F.tfoot=F.colgroup=F.caption=F.thead;F.th=F.td;if(!c.support.htmlSerialize)F._default=[1,"div<div>","</div>"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d=
c(this);d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.text(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this},
wrapInner:function(a){if(c.isFunction(a))return this.each(function(b){c(this).wrapInner(a.call(this,b))});return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})},
prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,
this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},remove:function(a,b){for(var d=0,f;(f=this[d])!=null;d++)if(!a||c.filter(a,[f]).length){if(!b&&f.nodeType===1){c.cleanData(f.getElementsByTagName("*"));c.cleanData([f])}f.parentNode&&f.parentNode.removeChild(f)}return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++)for(b.nodeType===1&&c.cleanData(b.getElementsByTagName("*"));b.firstChild;)b.removeChild(b.firstChild);
return this},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ja,"").replace(/=([^="'>\s]+\/)>/g,'="$1">').replace(V,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ra(this,b);ra(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(Ja,
""):null;else if(typeof a==="string"&&!ta.test(a)&&(c.support.leadingWhitespace||!V.test(a))&&!F[(La.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Ka,Ma);try{for(var b=0,d=this.length;b<d;b++)if(this[b].nodeType===1){c.cleanData(this[b].getElementsByTagName("*"));this[b].innerHTML=a}}catch(f){this.empty().append(a)}}else c.isFunction(a)?this.each(function(e){var j=c(this),i=j.html();j.empty().append(function(){return a.call(this,e,i)})}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&
this[0].parentNode){if(c.isFunction(a))return this.each(function(b){var d=c(this),f=d.html();d.replaceWith(a.call(this,b,f))});if(typeof a!=="string")a=c(a).detach();return this.each(function(){var b=this.nextSibling,d=this.parentNode;c(this).remove();b?c(b).before(a):c(d).append(a)})}else return this.pushStack(c(c.isFunction(a)?a():a),"replaceWith",a)},detach:function(a){return this.remove(a,true)},domManip:function(a,b,d){function f(u){return c.nodeName(u,"table")?u.getElementsByTagName("tbody")[0]||
u.appendChild(u.ownerDocument.createElement("tbody")):u}var e,j,i=a[0],o=[],k;if(!c.support.checkClone&&arguments.length===3&&typeof i==="string"&&ua.test(i))return this.each(function(){c(this).domManip(a,b,d,true)});if(c.isFunction(i))return this.each(function(u){var z=c(this);a[0]=i.call(this,u,b?z.html():w);z.domManip(a,b,d)});if(this[0]){e=i&&i.parentNode;e=c.support.parentNode&&e&&e.nodeType===11&&e.childNodes.length===this.length?{fragment:e}:sa(a,this,o);k=e.fragment;if(j=k.childNodes.length===
1?(k=k.firstChild):k.firstChild){b=b&&c.nodeName(j,"tr");for(var n=0,r=this.length;n<r;n++)d.call(b?f(this[n],j):this[n],n>0||e.cacheable||this.length>1?k.cloneNode(true):k)}o.length&&c.each(o,Qa)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){c.fn[a]=function(d){var f=[];d=c(d);var e=this.length===1&&this[0].parentNode;if(e&&e.nodeType===11&&e.childNodes.length===1&&d.length===1){d[b](this[0]);
return this}else{e=0;for(var j=d.length;e<j;e++){var i=(e>0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),i);f=f.concat(i)}return this.pushStack(f,a,d.selector)}}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;for(var e=[],j=0,i;(i=a[j])!=null;j++){if(typeof i==="number")i+="";if(i){if(typeof i==="string"&&!jb.test(i))i=b.createTextNode(i);else if(typeof i==="string"){i=i.replace(Ka,Ma);var o=(La.exec(i)||["",
""])[1].toLowerCase(),k=F[o]||F._default,n=k[0],r=b.createElement("div");for(r.innerHTML=k[1]+i+k[2];n--;)r=r.lastChild;if(!c.support.tbody){n=ib.test(i);o=o==="table"&&!n?r.firstChild&&r.firstChild.childNodes:k[1]==="<table>"&&!n?r.childNodes:[];for(k=o.length-1;k>=0;--k)c.nodeName(o[k],"tbody")&&!o[k].childNodes.length&&o[k].parentNode.removeChild(o[k])}!c.support.leadingWhitespace&&V.test(i)&&r.insertBefore(b.createTextNode(V.exec(i)[0]),r.firstChild);i=r.childNodes}if(i.nodeType)e.push(i);else e=
c.merge(e,i)}}if(d)for(j=0;e[j];j++)if(f&&c.nodeName(e[j],"script")&&(!e[j].type||e[j].type.toLowerCase()==="text/javascript"))f.push(e[j].parentNode?e[j].parentNode.removeChild(e[j]):e[j]);else{e[j].nodeType===1&&e.splice.apply(e,[j+1,0].concat(c.makeArray(e[j].getElementsByTagName("script"))));d.appendChild(e[j])}return e},cleanData:function(a){for(var b,d,f=c.cache,e=c.event.special,j=c.support.deleteExpando,i=0,o;(o=a[i])!=null;i++)if(d=o[c.expando]){b=f[d];if(b.events)for(var k in b.events)e[k]?
c.event.remove(o,k):Ca(o,k,b.handle);if(j)delete o[c.expando];else o.removeAttribute&&o.removeAttribute(c.expando);delete f[d]}}});var kb=/z-?index|font-?weight|opacity|zoom|line-?height/i,Na=/alpha\([^)]*\)/,Oa=/opacity=([^)]*)/,ha=/float/i,ia=/-([a-z])/ig,lb=/([A-Z])/g,mb=/^-?\d+(?:px)?$/i,nb=/^-?\d/,ob={position:"absolute",visibility:"hidden",display:"block"},pb=["Left","Right"],qb=["Top","Bottom"],rb=s.defaultView&&s.defaultView.getComputedStyle,Pa=c.support.cssFloat?"cssFloat":"styleFloat",ja=
function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return X(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!kb.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""==="NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter=
Na.test(a)?a.replace(Na,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Oa.exec(f.filter)[1])/100+"":""}if(ha.test(b))b=Pa;b=b.replace(ia,ja);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,j=b==="width"?pb:qb;function i(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(j,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a,
"border"+this+"Width",true))||0})}a.offsetWidth!==0?i():c.swap(a,ob,i);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Oa.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ha.test(b))b=Pa;if(!d&&e&&e[b])f=e[b];else if(rb){if(ha.test(b))b="float";b=b.replace(lb,"-$1").toLowerCase();e=a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f=
a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ia,ja);f=a.currentStyle[b]||a.currentStyle[d];if(!mb.test(f)&&nb.test(f)){b=e.left;var j=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=j}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b=
a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var sb=J(),tb=/<script(.|\s)*?\/script>/gi,ub=/select|textarea/i,vb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,N=/=\?(&|$)/,ka=/\?/,wb=/(\?|&)_=.*?(&|$)/,xb=/^(\w+:)?\/\/([^\/?#]+)/,yb=/%20/g,zb=c.fn.load;c.fn.extend({load:function(a,b,d){if(typeof a!==
"string")return zb.call(this,a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}var j=this;c.ajax({url:a,type:f,dataType:"html",data:b,complete:function(i,o){if(o==="success"||o==="notmodified")j.html(e?c("<div />").append(i.responseText.replace(tb,"")).find(e):i.responseText);d&&j.each(d,[i.responseText,o,i])}});return this},
serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ub.test(this.nodeName)||vb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),
function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href,
global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&&
e.success.call(k,o,i,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(k,x,i);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(q,p){(e.context?c(e.context):c.event).trigger(q,p)}var e=c.extend(true,{},c.ajaxSettings,a),j,i,o,k=a&&a.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,e.traditional);if(e.dataType==="jsonp"){if(n==="GET")N.test(e.url)||(e.url+=(ka.test(e.url)?
"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!N.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&N.test(e.data)||N.test(e.url))){j=e.jsonpCallback||"jsonp"+sb++;if(e.data)e.data=(e.data+"").replace(N,"="+j+"$1");e.url=e.url.replace(N,"="+j+"$1");e.dataType="script";A[j]=A[j]||function(q){o=q;b();d();A[j]=w;try{delete A[j]}catch(p){}z&&z.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache===
false&&n==="GET"){var r=J(),u=e.url.replace(wb,"$1_="+r+"$2");e.url=u+(u===e.url?(ka.test(e.url)?"&":"?")+"_="+r:"")}if(e.data&&n==="GET")e.url+=(ka.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");r=(r=xb.exec(e.url))&&(r[1]&&r[1]!==location.protocol||r[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&r){var z=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!j){var B=
false;C.onload=C.onreadystatechange=function(){if(!B&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){B=true;b();d();C.onload=C.onreadystatechange=null;z&&C.parentNode&&z.removeChild(C)}}}z.insertBefore(C,z.firstChild);return w}var E=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since",
c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}r||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ga){}if(e.beforeSend&&e.beforeSend.call(k,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",[x,e]);var g=x.onreadystatechange=function(q){if(!x||x.readyState===0||q==="abort"){E||
d();E=true;if(x)x.onreadystatechange=c.noop}else if(!E&&x&&(x.readyState===4||q==="timeout")){E=true;x.onreadystatechange=c.noop;i=q==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";var p;if(i==="success")try{o=c.httpData(x,e.dataType,e)}catch(v){i="parsererror";p=v}if(i==="success"||i==="notmodified")j||b();else c.handleError(e,x,i,p);d();q==="timeout"&&x.abort();if(e.async)x=null}};try{var h=x.abort;x.abort=function(){x&&h.call(x);
g("abort")}}catch(l){}e.async&&e.timeout>0&&setTimeout(function(){x&&!E&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||a,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol==="file:"||a.status>=200&&a.status<300||a.status===304||a.status===
1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;e&&a.documentElement.nodeName==="parsererror"&&c.error("parsererror");if(d&&d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b===
"json"||!b&&f.indexOf("json")>=0)a=c.parseJSON(a);else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(i,o){if(c.isArray(o))c.each(o,function(k,n){b||/\[\]$/.test(i)?f(i,n):d(i+"["+(typeof n==="object"||c.isArray(n)?k:"")+"]",n)});else!b&&o!=null&&typeof o==="object"?c.each(o,function(k,n){d(i+"["+k+"]",n)}):f(i,o)}function f(i,o){o=c.isFunction(o)?o():o;e[e.length]=encodeURIComponent(i)+"="+encodeURIComponent(o)}var e=[];if(b===w)b=c.ajaxSettings.traditional;
if(c.isArray(a)||a.jquery)c.each(a,function(){f(this.name,this.value)});else for(var j in a)d(j,a[j]);return e.join("&").replace(yb,"+")}});var la={},Ab=/toggle|show|hide/,Bb=/^([+-]=)?([\d+-.]+)(.*)$/,W,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a||a===0)return this.animate(K("show",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");
this[a].style.display=d||"";if(c.css(this[a],"display")==="none"){d=this[a].nodeName;var f;if(la[d])f=la[d];else{var e=c("<"+d+" />").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();la[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a<b;a++)this[a].style.display=c.data(this[a],"olddisplay")||"";return this}},hide:function(a,b){if(a||a===0)return this.animate(K("hide",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");!d&&d!=="none"&&c.data(this[a],
"olddisplay",c.css(this[a],"display"))}a=0;for(b=this.length;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b){var d=typeof a==="boolean";if(c.isFunction(a)&&c.isFunction(b))this._toggle.apply(this,arguments);else a==null||d?this.each(function(){var f=d?a:c(this).is(":hidden");c(this)[f?"show":"hide"]()}):this.animate(K("toggle",3),a,b);return this},fadeTo:function(a,b,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,d)},
animate:function(a,b,d,f){var e=c.speed(b,d,f);if(c.isEmptyObject(a))return this.each(e.complete);return this[e.queue===false?"each":"queue"](function(){var j=c.extend({},e),i,o=this.nodeType===1&&c(this).is(":hidden"),k=this;for(i in a){var n=i.replace(ia,ja);if(i!==n){a[n]=a[i];delete a[i];i=n}if(a[i]==="hide"&&o||a[i]==="show"&&!o)return j.complete.call(this);if((i==="height"||i==="width")&&this.style){j.display=c.css(this,"display");j.overflow=this.style.overflow}if(c.isArray(a[i])){(j.specialEasing=
j.specialEasing||{})[i]=a[i][1];a[i]=a[i][0]}}if(j.overflow!=null)this.style.overflow="hidden";j.curAnim=c.extend({},a);c.each(a,function(r,u){var z=new c.fx(k,j,r);if(Ab.test(u))z[u==="toggle"?o?"show":"hide":u](a);else{var C=Bb.exec(u),B=z.cur(true)||0;if(C){u=parseFloat(C[2]);var E=C[3]||"px";if(E!=="px"){k.style[r]=(u||1)+E;B=(u||1)/z.cur(true)*B;k.style[r]=B+E}if(C[1])u=(C[1]==="-="?-1:1)*u+B;z.custom(B,u,E)}else z.custom(B,u,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);
this.each(function(){for(var f=d.length-1;f>=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:K("show",1),slideUp:K("hide",1),slideToggle:K("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration===
"number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||
c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(j){return e.step(j)}this.startTime=J();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;
this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!W)W=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=J(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=
this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem,
e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||
c.fx.stop()},stop:function(){clearInterval(W);W=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){if(a.elem.style&&a.elem.style[a.prop]!=null)a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit;else a.elem[a.prop]=a.now}}});if(c.expr&&c.expr.filters)c.expr.filters.animated=function(a){return c.grep(c.timers,function(b){return a===b.elem}).length};c.fn.offset="getBoundingClientRect"in s.documentElement?
function(a){var b=this[0];if(a)return this.each(function(e){c.offset.setOffset(this,a,e)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);var d=b.getBoundingClientRect(),f=b.ownerDocument;b=f.body;f=f.documentElement;return{top:d.top+(self.pageYOffset||c.support.boxModel&&f.scrollTop||b.scrollTop)-(f.clientTop||b.clientTop||0),left:d.left+(self.pageXOffset||c.support.boxModel&&f.scrollLeft||b.scrollLeft)-(f.clientLeft||b.clientLeft||0)}}:function(a){var b=
this[0];if(a)return this.each(function(r){c.offset.setOffset(this,a,r)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);c.offset.initialize();var d=b.offsetParent,f=b,e=b.ownerDocument,j,i=e.documentElement,o=e.body;f=(e=e.defaultView)?e.getComputedStyle(b,null):b.currentStyle;for(var k=b.offsetTop,n=b.offsetLeft;(b=b.parentNode)&&b!==o&&b!==i;){if(c.offset.supportsFixedPosition&&f.position==="fixed")break;j=e?e.getComputedStyle(b,null):b.currentStyle;
k-=b.scrollTop;n-=b.scrollLeft;if(b===d){k+=b.offsetTop;n+=b.offsetLeft;if(c.offset.doesNotAddBorder&&!(c.offset.doesAddBorderForTableAndCells&&/^t(able|d|h)$/i.test(b.nodeName))){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=d;d=b.offsetParent}if(c.offset.subtractsBorderForOverflowNotVisible&&j.overflow!=="visible"){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=j}if(f.position==="relative"||f.position==="static"){k+=o.offsetTop;n+=o.offsetLeft}if(c.offset.supportsFixedPosition&&
f.position==="fixed"){k+=Math.max(i.scrollTop,o.scrollTop);n+=Math.max(i.scrollLeft,o.scrollLeft)}return{top:k,left:n}};c.offset={initialize:function(){var a=s.body,b=s.createElement("div"),d,f,e,j=parseFloat(c.curCSS(a,"marginTop",true))||0;c.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
a.insertBefore(b,a.firstChild);d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==j;a.removeChild(b);
c.offset.initialize=c.noop},bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),j=parseInt(c.curCSS(a,"top",true),10)||0,i=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a,
d,e);d={top:b.top-e.top+j,left:b.left-e.left+i};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top-
f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],j;if(!e)return null;if(f!==w)return this.each(function(){if(j=wa(this))j.scrollTo(!a?f:c(j).scrollLeft(),a?f:c(j).scrollTop());else this[d]=f});else return(j=wa(e))?"pageXOffset"in j?j[a?"pageYOffset":
"pageXOffset"]:c.support.boxModel&&j.document.documentElement[d]||j.document.body[d]:e[d]}});c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;if(c.isFunction(f))return this.each(function(j){var i=c(this);i[d](f.call(this,j,i[d]()))});return"scrollTo"in
e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window);

18
docs/html/_static/mathjax_mathml.user.js
View File

@ -1,18 +0,0 @@
// ==UserScript==
// @name MathJax MathML
// @namespace http://www.mathjax.org/
// @description Insert MathJax into pages containing MathML
// @include *
// ==/UserScript==
if ((window.unsafeWindow == null ? window : unsafeWindow).MathJax == null) {
if ((document.getElementsByTagName("math").length > 0) ||
(document.getElementsByTagNameNS == null ? false :
(document.getElementsByTagNameNS("http://www.w3.org/1998/Math/MathML","math").length > 0))) {
var script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML-full";
var config = 'MathJax.Hub.Startup.onload()';
document.getElementsByTagName("head")[0].appendChild(script);
}
}

30
docs/html/_static/mathjax_wikipedia.user.js
View File

@ -1,30 +0,0 @@
// ==UserScript==
// @name MathJax in Wikipedia
// @namespace http://www.mathjax.org/
// @description Insert MathJax into Wikipedia pages
// @include http://en.wikipedia.org/wiki/*
// ==/UserScript==
if ((window.unsafeWindow == null ? window : unsafeWindow).MathJax == null) {
//
// Replace the images with MathJax scripts of type math/tex
//
var images = document.getElementsByTagName('img'), count = 0;
for (var i = images.length - 1; i >= 0; i--) {
var img = images[i];
if (img.className === "tex") {
var script = document.createElement("script"); script.type = "math/tex";
if (window.opera) {script.innerHTML = img.alt} else {script.text = img.alt}
img.parentNode.replaceChild(script,img); count++;
}
}
if (count) {
//
// Load MathJax and have it process the page
//
var script = document.createElement("script");
script.type = "text/javascript";
script.src = "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML-full";
document.getElementsByTagName("head")[0].appendChild(script);
}
}

BIN
docs/html/_static/minus.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 199 B

226
docs/html/_static/mj.css
View File

@ -1,226 +0,0 @@
/**
* Sphinx stylesheet -- default theme
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
@import url("basic.css");
/* -- page layout ----------------------------------------------------------- */
body {
font-family: sans-serif;
font-size: 100%;
background-color: #11303d;
color: #000;
margin: 0;
padding: 0;
}
div.document {
background-color: #d4e9f7;
}
div.documentwrapper {
float: left;
width: 100%;
}
div.bodywrapper {
margin: 0 0 0 230px;
}
div.body {
background-color: #ffffff;
color: #222222;
padding: 0 20px 30px 20px;
}
div.footer {
color: #ffffff;
width: 100%;
padding: 9px 0 9px 0;
text-align: center;
font-size: 75%;
}
div.footer a {
color: #ffffff;
text-decoration: underline;
}
div.related {
background-color: #191a19;
line-height: 30px;
color: #ffffff;
}
div.related a {
color: #ffffff;
}
div.sphinxsidebar {
}
div.sphinxsidebar h3 {
font-family: 'Trebuchet MS', sans-serif;
color: #3a3a3a;
font-size: 1.4em;
font-weight: normal;
margin: 0;
padding: 0;
}
div.sphinxsidebar h3 a {
color: #3a3a3a;
}
div.sphinxsidebar h4 {
font-family: 'Trebuchet MS', sans-serif;
color: #3a3a3a;
font-size: 1.3em;
font-weight: normal;
margin: 5px 0 0 0;
padding: 0;
}
div.sphinxsidebar p {
color: #3a3a3a;
}
div.sphinxsidebar p.topless {
margin: 5px 10px 10px 10px;
}
div.sphinxsidebar ul {
margin: 10px;
padding: 0;
color: #3a3a3a;
}
div.sphinxsidebar ul li {
margin-top: .2em;
}
div.sphinxsidebar a {
color: #3a8942;
}
div.sphinxsidebar input {
border: 1px solid #3a8942;
font-family: sans-serif;
font-size: 1em;
}
/* -- body styles ----------------------------------------------------------- */
a {
color: #355f7c;
text-decoration: none;
}
a:hover {
text-decoration: underline;
}
div.body p, div.body dd, div.body li {
text-align: justify;
line-height: 130%;
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 {
font-family: 'Trebuchet MS', sans-serif;
background-color: #f2f2f2;
font-weight: normal;
color: #20435c;
border-top: 2px solid #cccccc;
border-bottom: 1px solid #cccccc;
margin: 30px -20px 20px -20px;
padding: 3px 0 3px 10px;
}
div.body h1 { margin-top: 0; font-size: 200%; }
div.body h2 { font-size: 160%; }
div.body h3 { font-size: 140%; padding-left: 20px; }
div.body h4 { font-size: 120%; padding-left: 20px; }
div.body h5 { font-size: 110%; padding-left: 20px; }
div.body h6 { font-size: 100%; padding-left: 20px; }
a.headerlink {
color: #c60f0f;
font-size: 0.8em;
padding: 0 4px 0 4px;
text-decoration: none;
}
a.headerlink:hover {
background-color: #c60f0f;
color: white;
}
div.body p, div.body dd, div.body li {
text-align: justify;
line-height: 130%;
}
div.admonition p.admonition-title + p {
display: inline;
}
div.note {
background-color: #eee;
border: 1px solid #ccc;
}
div.seealso {
background-color: #ffc;
border: 1px solid #ff6;
}
div.topic {
background-color: #eee;
}
div.warning {
background-color: #ffe4e4;
border: 1px solid #f66;
}
p.admonition-title {
display: inline;
}
p.admonition-title:after {
content: ":";
}
pre {
padding: 5px;
background-color: #f1f8ff;
color: #333333;
line-height: 130%;
border: 2px solid #6799b3;
border-left: none;
border-right: none;
}
tt {
background-color: #ecf0f3;
padding: 0 1px 0 1px;
/* font-size: 0.95em;*/
}
.warning tt {
background: #efc2c2;
}
.note tt {
background: #d6d6d6;
}

BIN
docs/html/_static/plus.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 199 B

62
docs/html/_static/pygments.css
View File

@ -1,62 +0,0 @@
.highlight .hll { background-color: #ffffcc }
.highlight { background: #eeffcc; }
.highlight .c { color: #408090; font-style: italic } /* Comment */
.highlight .err { border: 1px solid #FF0000 } /* Error */
.highlight .k { color: #007020; font-weight: bold } /* Keyword */
.highlight .o { color: #666666 } /* Operator */
.highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #007020 } /* Comment.Preproc */
.highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
.highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #A00000 } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #FF0000 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #303030 } /* Generic.Output */
.highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #0040D0 } /* Generic.Traceback */
.highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #007020 } /* Keyword.Pseudo */
.highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #902000 } /* Keyword.Type */
.highlight .m { color: #208050 } /* Literal.Number */
.highlight .s { color: #4070a0 } /* Literal.String */
.highlight .na { color: #4070a0 } /* Name.Attribute */
.highlight .nb { color: #007020 } /* Name.Builtin */
.highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
.highlight .no { color: #60add5 } /* Name.Constant */
.highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
.highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
.highlight .ne { color: #007020 } /* Name.Exception */
.highlight .nf { color: #06287e } /* Name.Function */
.highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
.highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
.highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #bb60d5 } /* Name.Variable */
.highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mf { color: #208050 } /* Literal.Number.Float */
.highlight .mh { color: #208050 } /* Literal.Number.Hex */
.highlight .mi { color: #208050 } /* Literal.Number.Integer */
.highlight .mo { color: #208050 } /* Literal.Number.Oct */
.highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
.highlight .sc { color: #4070a0 } /* Literal.String.Char */
.highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
.highlight .s2 { color: #4070a0 } /* Literal.String.Double */
.highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
.highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
.highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
.highlight .sx { color: #c65d09 } /* Literal.String.Other */
.highlight .sr { color: #235388 } /* Literal.String.Regex */
.highlight .s1 { color: #4070a0 } /* Literal.String.Single */
.highlight .ss { color: #517918 } /* Literal.String.Symbol */
.highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
.highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
.highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
.highlight .il { color: #208050 } /* Literal.Number.Integer.Long */

518
docs/html/_static/searchtools.js
View File

@ -1,518 +0,0 @@
/*
* searchtools.js
* ~~~~~~~~~~~~~~
*
* Sphinx JavaScript utilties for the full-text search.
*
* :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
*
*/
/**
* helper function to return a node containing the
* search summary for a given text. keywords is a list
* of stemmed words, hlwords is the list of normal, unstemmed
* words. the first one is used to find the occurance, the
* latter for highlighting it.
*/
jQuery.makeSearchSummary = function(text, keywords, hlwords) {
var textLower = text.toLowerCase();
var start = 0;
$.each(keywords, function() {
var i = textLower.indexOf(this.toLowerCase());
if (i > -1)
start = i;
});
start = Math.max(start - 120, 0);
var excerpt = ((start > 0) ? '...' : '') +
$.trim(text.substr(start, 240)) +
((start + 240 - text.length) ? '...' : '');
var rv = $('<div class="context"></div>').text(excerpt);
$.each(hlwords, function() {
rv = rv.highlightText(this, 'highlighted');
});
return rv;
}
/**
* Porter Stemmer
*/
var PorterStemmer = function() {
var step2list = {
ational: 'ate',
tional: 'tion',
enci: 'ence',
anci: 'ance',
izer: 'ize',
bli: 'ble',
alli: 'al',
entli: 'ent',
eli: 'e',
ousli: 'ous',
ization: 'ize',
ation: 'ate',
ator: 'ate',
alism: 'al',
iveness: 'ive',
fulness: 'ful',
ousness: 'ous',
aliti: 'al',
iviti: 'ive',
biliti: 'ble',
logi: 'log'
};
var step3list = {
icate: 'ic',
ative: '',
alize: 'al',
iciti: 'ic',
ical: 'ic',
ful: '',
ness: ''
};
var c = "[^aeiou]"; // consonant
var v = "[aeiouy]"; // vowel
var C = c + "[^aeiouy]*"; // consonant sequence
var V = v + "[aeiou]*"; // vowel sequence
var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
var s_v = "^(" + C + ")?" + v; // vowel in stem
this.stemWord = function (w) {
var stem;
var suffix;
var firstch;
var origword = w;
if (w.length < 3)
return w;
var re;
var re2;
var re3;
var re4;
firstch = w.substr(0,1);
if (firstch == "y")
w = firstch.toUpperCase() + w.substr(1);
// Step 1a
re = /^(.+?)(ss|i)es$/;
re2 = /^(.+?)([^s])s$/;
if (re.test(w))
w = w.replace(re,"$1$2");
else if (re2.test(w))
w = w.replace(re2,"$1$2");
// Step 1b
re = /^(.+?)eed$/;
re2 = /^(.+?)(ed|ing)$/;
if (re.test(w)) {
var fp = re.exec(w);
re = new RegExp(mgr0);
if (re.test(fp[1])) {
re = /.$/;
w = w.replace(re,"");
}
}
else if (re2.test(w)) {
var fp = re2.exec(w);
stem = fp[1];
re2 = new RegExp(s_v);
if (re2.test(stem)) {
w = stem;
re2 = /(at|bl|iz)$/;
re3 = new RegExp("([^aeiouylsz])\\1$");
re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
if (re2.test(w))
w = w + "e";
else if (re3.test(w)) {
re = /.$/;
w = w.replace(re,"");
}
else if (re4.test(w))
w = w + "e";
}
}
// Step 1c
re = /^(.+?)y$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(s_v);
if (re.test(stem))
w = stem + "i";
}
// Step 2
re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
suffix = fp[2];
re = new RegExp(mgr0);
if (re.test(stem))
w = stem + step2list[suffix];
}
// Step 3
re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
suffix = fp[2];
re = new RegExp(mgr0);
if (re.test(stem))
w = stem + step3list[suffix];
}
// Step 4
re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
re2 = /^(.+?)(s|t)(ion)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(mgr1);
if (re.test(stem))
w = stem;
}
else if (re2.test(w)) {
var fp = re2.exec(w);
stem = fp[1] + fp[2];
re2 = new RegExp(mgr1);
if (re2.test(stem))
w = stem;
}
// Step 5
re = /^(.+?)e$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(mgr1);
re2 = new RegExp(meq1);
re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
w = stem;
}
re = /ll$/;
re2 = new RegExp(mgr1);
if (re.test(w) && re2.test(w)) {
re = /.$/;
w = w.replace(re,"");
}
// and turn initial Y back to y
if (firstch == "y")
w = firstch.toLowerCase() + w.substr(1);
return w;
}
}
/**
* Search Module
*/
var Search = {
_index : null,
_queued_query : null,
_pulse_status : -1,
init : function() {
var params = $.getQueryParameters();
if (params.q) {
var query = params.q[0];
$('input[name="q"]')[0].value = query;
this.performSearch(query);
}
},
loadIndex : function(url) {
$.ajax({type: "GET", url: url, data: null, success: null,
dataType: "script", cache: true});
},
setIndex : function(index) {
var q;
this._index = index;
if ((q = this._queued_query) !== null) {
this._queued_query = null;
Search.query(q);
}
},
hasIndex : function() {
return this._index !== null;
},
deferQuery : function(query) {
this._queued_query = query;
},
stopPulse : function() {
this._pulse_status = 0;
},
startPulse : function() {
if (this._pulse_status >= 0)
return;
function pulse() {
Search._pulse_status = (Search._pulse_status + 1) % 4;
var dotString = '';
for (var i = 0; i < Search._pulse_status; i++)
dotString += '.';
Search.dots.text(dotString);
if (Search._pulse_status > -1)
window.setTimeout(pulse, 500);
};
pulse();
},
/**
* perform a search for something
*/
performSearch : function(query) {
// create the required interface elements
this.out = $('#search-results');
this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
this.dots = $('<span></span>').appendTo(this.title);
this.status = $('<p style="display: none"></p>').appendTo(this.out);
this.output = $('<ul class="search"/>').appendTo(this.out);
$('#search-progress').text(_('Preparing search...'));
this.startPulse();
// index already loaded, the browser was quick!
if (this.hasIndex())
this.query(query);
else
this.deferQuery(query);
},
query : function(query) {
var stopwords = ['and', 'then', 'into', 'it', 'as', 'are', 'in',
'if', 'for', 'no', 'there', 'their', 'was', 'is',
'be', 'to', 'that', 'but', 'they', 'not', 'such',
'with', 'by', 'a', 'on', 'these', 'of', 'will',
'this', 'near', 'the', 'or', 'at'];
// stem the searchterms and add them to the correct list
var stemmer = new PorterStemmer();
var searchterms = [];
var excluded = [];
var hlterms = [];
var tmp = query.split(/\s+/);
var object = (tmp.length == 1) ? tmp[0].toLowerCase() : null;
for (var i = 0; i < tmp.length; i++) {
if ($u.indexOf(stopwords, tmp[i]) != -1 || tmp[i].match(/^\d+$/) ||
tmp[i] == "") {
// skip this "word"
continue;
}
// stem the word
var word = stemmer.stemWord(tmp[i]).toLowerCase();
// select the correct list
if (word[0] == '-') {
var toAppend = excluded;
word = word.substr(1);
}
else {
var toAppend = searchterms;
hlterms.push(tmp[i].toLowerCase());
}
// only add if not already in the list
if (!$.contains(toAppend, word))
toAppend.push(word);
};
var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
// console.debug('SEARCH: searching for:');
// console.info('required: ', searchterms);
// console.info('excluded: ', excluded);
// prepare search
var filenames = this._index.filenames;
var titles = this._index.titles;
var terms = this._index.terms;
var objects = this._index.objects;
var objtypes = this._index.objtypes;
var objnames = this._index.objnames;
var fileMap = {};
var files = null;
// different result priorities
var importantResults = [];
var objectResults = [];
var regularResults = [];
var unimportantResults = [];
$('#search-progress').empty();
// lookup as object
if (object != null) {
for (var prefix in objects) {
for (var name in objects[prefix]) {
var fullname = (prefix ? prefix + '.' : '') + name;
if (fullname.toLowerCase().indexOf(object) > -1) {
match = objects[prefix][name];
descr = objnames[match[1]] + _(', in ') + titles[match[0]];
// XXX the generated anchors are not generally correct
// XXX there may be custom prefixes
result = [filenames[match[0]], fullname, '#'+fullname, descr];
switch (match[2]) {
case 1: objectResults.push(result); break;
case 0: importantResults.push(result); break;
case 2: unimportantResults.push(result); break;
}
}
}
}
}
// sort results descending
objectResults.sort(function(a, b) {
return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
});
importantResults.sort(function(a, b) {
return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
});
unimportantResults.sort(function(a, b) {
return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
});
// perform the search on the required terms
for (var i = 0; i < searchterms.length; i++) {
var word = searchterms[i];
// no match but word was a required one
if ((files = terms[word]) == null)
break;
if (files.length == undefined) {
files = [files];
}
// create the mapping
for (var j = 0; j < files.length; j++) {
var file = files[j];
if (file in fileMap)
fileMap[file].push(word);
else
fileMap[file] = [word];
}
}
// now check if the files don't contain excluded terms
for (var file in fileMap) {
var valid = true;
// check if all requirements are matched
if (fileMap[file].length != searchterms.length)
continue;
// ensure that none of the excluded terms is in the
// search result.
for (var i = 0; i < excluded.length; i++) {
if (terms[excluded[i]] == file ||
$.contains(terms[excluded[i]] || [], file)) {
valid = false;
break;
}
}
// if we have still a valid result we can add it
// to the result list
if (valid)
regularResults.push([filenames[file], titles[file], '', null]);
}
// delete unused variables in order to not waste
// memory until list is retrieved completely
delete filenames, titles, terms;
// now sort the regular results descending by title
regularResults.sort(function(a, b) {
var left = a[1].toLowerCase();
var right = b[1].toLowerCase();
return (left > right) ? -1 : ((left < right) ? 1 : 0);
});
// combine all results
var results = unimportantResults.concat(regularResults)
.concat(objectResults).concat(importantResults);
// print the results
var resultCount = results.length;
function displayNextItem() {
// results left, load the summary and display it
if (results.length) {
var item = results.pop();
var listItem = $('<li style="display:none"></li>');
if (DOCUMENTATION_OPTIONS.FILE_SUFFIX == '') {
// dirhtml builder
var dirname = item[0] + '/';
if (dirname.match(/\/index\/$/)) {
dirname = dirname.substring(0, dirname.length-6);
} else if (dirname == 'index/') {
dirname = '';
}
listItem.append($('<a/>').attr('href',
DOCUMENTATION_OPTIONS.URL_ROOT + dirname +
highlightstring + item[2]).html(item[1]));
} else {
// normal html builders
listItem.append($('<a/>').attr('href',
item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
highlightstring + item[2]).html(item[1]));
}
if (item[3]) {
listItem.append($('<span> (' + item[3] + ')</span>'));
Search.output.append(listItem);
listItem.slideDown(5, function() {
displayNextItem();
});
} else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
$.get(DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' +
item[0] + '.txt', function(data) {
if (data != '') {
listItem.append($.makeSearchSummary(data, searchterms, hlterms));
Search.output.append(listItem);
}
listItem.slideDown(5, function() {
displayNextItem();
});
});
} else {
// no source available, just display title
Search.output.append(listItem);
listItem.slideDown(5, function() {
displayNextItem();
});
}
}
// search finished, update title and status message
else {
Search.stopPulse();
Search.title.text(_('Search Results'));
if (!resultCount)
Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
else
Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
Search.status.fadeIn(500);
}
}
displayNextItem();
}
}
$(document).ready(function() {
Search.init();
});

16
docs/html/_static/underscore.js
View File

@ -1,16 +0,0 @@
(function(){var j=this,n=j._,i=function(a){this._wrapped=a},m=typeof StopIteration!=="undefined"?StopIteration:"__break__",b=j._=function(a){return new i(a)};if(typeof exports!=="undefined")exports._=b;var k=Array.prototype.slice,o=Array.prototype.unshift,p=Object.prototype.toString,q=Object.prototype.hasOwnProperty,r=Object.prototype.propertyIsEnumerable;b.VERSION="0.5.5";b.each=function(a,c,d){try{if(a.forEach)a.forEach(c,d);else if(b.isArray(a)||b.isArguments(a))for(var e=0,f=a.length;e<f;e++)c.call(d,
a[e],e,a);else{var g=b.keys(a);f=g.length;for(e=0;e<f;e++)c.call(d,a[g[e]],g[e],a)}}catch(h){if(h!=m)throw h;}return a};b.map=function(a,c,d){if(a&&b.isFunction(a.map))return a.map(c,d);var e=[];b.each(a,function(f,g,h){e.push(c.call(d,f,g,h))});return e};b.reduce=function(a,c,d,e){if(a&&b.isFunction(a.reduce))return a.reduce(b.bind(d,e),c);b.each(a,function(f,g,h){c=d.call(e,c,f,g,h)});return c};b.reduceRight=function(a,c,d,e){if(a&&b.isFunction(a.reduceRight))return a.reduceRight(b.bind(d,e),c);
var f=b.clone(b.toArray(a)).reverse();b.each(f,function(g,h){c=d.call(e,c,g,h,a)});return c};b.detect=function(a,c,d){var e;b.each(a,function(f,g,h){if(c.call(d,f,g,h)){e=f;b.breakLoop()}});return e};b.select=function(a,c,d){if(a&&b.isFunction(a.filter))return a.filter(c,d);var e=[];b.each(a,function(f,g,h){c.call(d,f,g,h)&&e.push(f)});return e};b.reject=function(a,c,d){var e=[];b.each(a,function(f,g,h){!c.call(d,f,g,h)&&e.push(f)});return e};b.all=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.every))return a.every(c,
d);var e=true;b.each(a,function(f,g,h){(e=e&&c.call(d,f,g,h))||b.breakLoop()});return e};b.any=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.some))return a.some(c,d);var e=false;b.each(a,function(f,g,h){if(e=c.call(d,f,g,h))b.breakLoop()});return e};b.include=function(a,c){if(b.isArray(a))return b.indexOf(a,c)!=-1;var d=false;b.each(a,function(e){if(d=e===c)b.breakLoop()});return d};b.invoke=function(a,c){var d=b.rest(arguments,2);return b.map(a,function(e){return(c?e[c]:e).apply(e,d)})};b.pluck=
function(a,c){return b.map(a,function(d){return d[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);var e={computed:-Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g>=e.computed&&(e={value:f,computed:g})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);var e={computed:Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g<e.computed&&(e={value:f,computed:g})});return e.value};b.sortBy=function(a,c,d){return b.pluck(b.map(a,
function(e,f,g){return{value:e,criteria:c.call(d,e,f,g)}}).sort(function(e,f){e=e.criteria;f=f.criteria;return e<f?-1:e>f?1:0}),"value")};b.sortedIndex=function(a,c,d){d=d||b.identity;for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?(e=g+1):(f=g)}return e};b.toArray=function(a){if(!a)return[];if(a.toArray)return a.toArray();if(b.isArray(a))return a;if(b.isArguments(a))return k.call(a);return b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=function(a,c,d){return c&&!d?k.call(a,
0,c):a[0]};b.rest=function(a,c,d){return k.call(a,b.isUndefined(c)||d?1:c)};b.last=function(a){return a[a.length-1]};b.compact=function(a){return b.select(a,function(c){return!!c})};b.flatten=function(a){return b.reduce(a,[],function(c,d){if(b.isArray(d))return c.concat(b.flatten(d));c.push(d);return c})};b.without=function(a){var c=b.rest(arguments);return b.select(a,function(d){return!b.include(c,d)})};b.uniq=function(a,c){return b.reduce(a,[],function(d,e,f){if(0==f||(c===true?b.last(d)!=e:!b.include(d,
e)))d.push(e);return d})};b.intersect=function(a){var c=b.rest(arguments);return b.select(b.uniq(a),function(d){return b.all(c,function(e){return b.indexOf(e,d)>=0})})};b.zip=function(){for(var a=b.toArray(arguments),c=b.max(b.pluck(a,"length")),d=new Array(c),e=0;e<c;e++)d[e]=b.pluck(a,String(e));return d};b.indexOf=function(a,c){if(a.indexOf)return a.indexOf(c);for(var d=0,e=a.length;d<e;d++)if(a[d]===c)return d;return-1};b.lastIndexOf=function(a,c){if(a.lastIndexOf)return a.lastIndexOf(c);for(var d=
a.length;d--;)if(a[d]===c)return d;return-1};b.range=function(a,c,d){var e=b.toArray(arguments),f=e.length<=1;a=f?0:e[0];c=f?e[0]:e[1];d=e[2]||1;e=Math.ceil((c-a)/d);if(e<=0)return[];e=new Array(e);f=a;for(var g=0;1;f+=d){if((d>0?f-c:c-f)>=0)return e;e[g++]=f}};b.bind=function(a,c){var d=b.rest(arguments,2);return function(){return a.apply(c||j,d.concat(b.toArray(arguments)))}};b.bindAll=function(a){var c=b.rest(arguments);if(c.length==0)c=b.functions(a);b.each(c,function(d){a[d]=b.bind(a[d],a)});
return a};b.delay=function(a,c){var d=b.rest(arguments,2);return setTimeout(function(){return a.apply(a,d)},c)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(b.rest(arguments)))};b.wrap=function(a,c){return function(){var d=[a].concat(b.toArray(arguments));return c.apply(c,d)}};b.compose=function(){var a=b.toArray(arguments);return function(){for(var c=b.toArray(arguments),d=a.length-1;d>=0;d--)c=[a[d].apply(this,c)];return c[0]}};b.keys=function(a){if(b.isArray(a))return b.range(0,a.length);
var c=[];for(var d in a)q.call(a,d)&&c.push(d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=function(a){return b.select(b.keys(a),function(c){return b.isFunction(a[c])}).sort()};b.extend=function(a,c){for(var d in c)a[d]=c[d];return a};b.clone=function(a){if(b.isArray(a))return a.slice(0);return b.extend({},a)};b.tap=function(a,c){c(a);return a};b.isEqual=function(a,c){if(a===c)return true;var d=typeof a;if(d!=typeof c)return false;if(a==c)return true;if(!a&&c||a&&!c)return false;
if(a.isEqual)return a.isEqual(c);if(b.isDate(a)&&b.isDate(c))return a.getTime()===c.getTime();if(b.isNaN(a)&&b.isNaN(c))return true;if(b.isRegExp(a)&&b.isRegExp(c))return a.source===c.source&&a.global===c.global&&a.ignoreCase===c.ignoreCase&&a.multiline===c.multiline;if(d!=="object")return false;if(a.length&&a.length!==c.length)return false;d=b.keys(a);var e=b.keys(c);if(d.length!=e.length)return false;for(var f in a)if(!b.isEqual(a[f],c[f]))return false;return true};b.isEmpty=function(a){return b.keys(a).length==
0};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=function(a){return!!(a&&a.concat&&a.unshift)};b.isArguments=function(a){return a&&b.isNumber(a.length)&&!b.isArray(a)&&!r.call(a,"length")};b.isFunction=function(a){return!!(a&&a.constructor&&a.call&&a.apply)};b.isString=function(a){return!!(a===""||a&&a.charCodeAt&&a.substr)};b.isNumber=function(a){return p.call(a)==="[object Number]"};b.isDate=function(a){return!!(a&&a.getTimezoneOffset&&a.setUTCFullYear)};b.isRegExp=function(a){return!!(a&&
a.test&&a.exec&&(a.ignoreCase||a.ignoreCase===false))};b.isNaN=function(a){return b.isNumber(a)&&isNaN(a)};b.isNull=function(a){return a===null};b.isUndefined=function(a){return typeof a=="undefined"};b.noConflict=function(){j._=n;return this};b.identity=function(a){return a};b.breakLoop=function(){throw m;};var s=0;b.uniqueId=function(a){var c=s++;return a?a+c:c};b.template=function(a,c){a=new Function("obj","var p=[],print=function(){p.push.apply(p,arguments);};with(obj){p.push('"+a.replace(/[\r\t\n]/g,
" ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');");return c?a(c):a};b.forEach=b.each;b.foldl=b.inject=b.reduce;b.foldr=b.reduceRight;b.filter=b.select;b.every=b.all;b.some=b.any;b.head=b.first;b.tail=b.rest;b.methods=b.functions;var l=function(a,c){return c?b(a).chain():a};b.each(b.functions(b),function(a){var c=b[a];i.prototype[a]=function(){var d=b.toArray(arguments);
o.call(d,this._wrapped);return l(c.apply(b,d),this._chain)}});b.each(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){c.apply(this._wrapped,arguments);return l(this._wrapped,this._chain)}});b.each(["concat","join","slice"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){return l(c.apply(this._wrapped,arguments),this._chain)}});i.prototype.chain=function(){this._chain=true;return this};i.prototype.value=function(){return this._wrapped}})();

436
docs/html/api/ajax.html
View File

@ -1,436 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Ajax Object &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Message Object" href="message.html" />
<link rel="prev" title="The MathJax.Hub Object" href="hub.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="message.html" title="The MathJax.Message Object"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="hub.html" title="The MathJax.Hub Object"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-ajax-object">
<span id="api-ajax"></span><h1>The MathJax.Ajax Object<a class="headerlink" href="#the-mathjax-ajax-object" title="Permalink to this headline"></a></h1>
<p>The <cite>MathJax.Ajax</cite> structure holds the data and functions for handling
loading of external modules. Modules are loaded only once, even if
called for in several places. The loading of files is asynchronous,
and so the code that requests an external module will continue to run
even when that module has not completed loading, so it is important to
be aware of the timing issues this may cause. Similarly, creating or
loading stylesheets is an asynchronous action. In particular, all
actions that rely on the file or stylesheet having been loaded must be
delayed until after the file has been downloaded completely. This is
the reason for the large number of routines that take callback
functions.</p>
<p>Any operation that could cause the loading of a file or stylesheet
must be synchronized with the rest of the code via such callbacks.
Since processing any mathematics might cause files to be loaded (e.g.,
little-used markup might be implemented in an extension that is loaded
only when that markup is used), any code that dynamically typesets
mathematics will need to be structured to use callbacks to guarantee
that the mathematics has been completely processed before the code
tries to use it. See the <a class="reference internal" href="../synchronize.html#synchronization"><em>Synchronizing with MathJax</em></a>
documentation for details on how to do this properly.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">timeout</tt></dt>
<dd><p>Number of milliseconds to wait for a file to load before
it is considered to have failed to load.</p>
<p><em>Default:</em> 15 seconds</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">STATUS.OK</tt></dt>
<dd><p>The value used to indicate that a file load has occurred
successfully.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">STATUS.ERROR</tt></dt>
<dd><p>The value used to indicate that a file load has caused an error or
a timeout to occur.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">loaded</tt></dt>
<dd><p>An object containing the names of the files that have been loaded (or
requested) so far. <tt class="docutils literal"><span class="pre">MathJax.Ajax.loaded[&quot;file&quot;]</span></tt> will be
non-<tt class="docutils literal"><span class="pre">null</span></tt> when the file has been loaded, with the value being
the <tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS</span></tt> value of the load attempt.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">loading</tt></dt>
<dd><p>An object containing the files that are currently loading, the
callbacks that are to be run when they load or timeout, and
additional internal data.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">loadHooks</tt></dt>
<dd><p>An object containing the load hooks for the various files, set up by
the <a class="reference internal" href="#LoadHook" title="LoadHook"><tt class="xref py py-meth docutils literal"><span class="pre">LoadHook()</span></tt></a> method, or by the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Hub.Register.LoadHook()</span></tt> method.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Require">
<tt class="descname">Require</tt><big>(</big><em>file</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Require" title="Permalink to this definition"></a></dt>
<dd><p>Loads the given file if it hasn&#8217;t been already. The file must be a
JavaScript file or a CSS stylesheet; i.e., it must end in <tt class="docutils literal"><span class="pre">.js</span></tt>
or <tt class="docutils literal"><span class="pre">.css</span></tt>. Alternatively, it can be an object with a single
<cite>key:value</cite> pair where the <cite>key</cite> is one of <tt class="docutils literal"><span class="pre">js</span></tt> or <tt class="docutils literal"><span class="pre">css</span></tt> and
the <cite>value</cite> is the file of that type to be loaded (this makes it
possible to have the file be created by a CGI script, for example,
or to use a <tt class="docutils literal"><span class="pre">data::</span></tt> URL). The file must be relative to the
MathJax home directory and can not contain <tt class="docutils literal"><span class="pre">../</span></tt> file path
components.</p>
<p>When the file is completely loaded and run, the <cite>callback</cite>, if
provided, will be executed passing it the status of the file load.
If there was an error while loading the file, or if the file fails
to load within the time limit given by <tt class="docutils literal"><span class="pre">MathJax.Ajax.timout</span></tt>,
the status will be <tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS.ERROR</span></tt> otherwise it
will be <tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS.OK</span></tt>. If the file is already
loaded, the callback will be called immediately and the file will
not be loaded again.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; name of the file to be loaded</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Load">
<tt class="descname">Load</tt><big>(</big><em>file</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Load" title="Permalink to this definition"></a></dt>
<dd><p>Used internally to load a given file without checking if it
already has been loaded, or where it is to be found.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; name of the file to be loaded</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="loadComplete">
<tt class="descname">loadComplete</tt><big>(</big><em>file</em><big>)</big><a class="headerlink" href="#loadComplete" title="Permalink to this definition"></a></dt>
<dd><p>Called from within the loaded files to inform MathJax that the
file has been completely loaded and initialized. The <cite>file</cite>
parameter is the name of the file that has been loaded. This
routine will cause any callback functions registered for the file
or included in the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> calls to be
executed, passing them the status of the load
(<tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS.OK</span></tt> or <tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS.ERROR</span></tt>) as
their last parameter.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; name of the file that has been loaded</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="loadTimeout">
<tt class="descname">loadTimeout</tt><big>(</big><em>file</em><big>)</big><a class="headerlink" href="#loadTimeout" title="Permalink to this definition"></a></dt>
<dd><p>Called when the timeout period is over and the file hasn&#8217;t loaded.
This indicates an error condition, and the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.loadError()</span></tt> method will be executed, then the
file&#8217;s callback will be run with <tt class="docutils literal"><span class="pre">MathJax.Ajax.STATUS.ERROR</span></tt> as
its parameter.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; name of the file that timed out</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="loadError">
<tt class="descname">loadError</tt><big>(</big><em>file</em><big>)</big><a class="headerlink" href="#loadError" title="Permalink to this definition"></a></dt>
<dd><p>The default error handler called when a file fails to load. It
puts a warning message into the MathJax message box on screen.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; the name of the file that failed to load</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="LoadHook">
<tt class="descname">LoadHook</tt><big>(</big><em>file</em>, <em>callback</em><big>)</big><a class="headerlink" href="#LoadHook" title="Permalink to this definition"></a></dt>
<dd><p>Registers a callback to be executed when the given file is
loaded. The file load operation needs to be started when this
method is called, so it can be used to register a hook for a file
that may be loaded in the future.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; the name of the file to wait for</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Preloading">
<tt class="descname">Preloading</tt><big>(</big><em>file1</em><span class="optional">[</span>, <em>file2...</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Preloading" title="Permalink to this definition"></a></dt>
<dd><p>Used with combined configuration files to indicate what files are
in the configuration file. Marks the files as loading (since there
will never be an explicit <a class="reference internal" href="#Load" title="Load"><tt class="xref py py-meth docutils literal"><span class="pre">Load()</span></tt></a> or <a class="reference internal" href="#Require" title="Require"><tt class="xref py py-meth docutils literal"><span class="pre">Require()</span></tt></a> call for
them), so that load-hooks and other load-related events can be
properly processed when the <a class="reference internal" href="#loadComplete" title="loadComplete"><tt class="xref py py-meth docutils literal"><span class="pre">loadComplete()</span></tt></a> occurs.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file1, file2, ...</strong> &#8212; the names of the files in the combined file</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Styles">
<tt class="descname">Styles</tt><big>(</big><em>styles</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Styles" title="Permalink to this definition"></a></dt>
<dd><p>Creates a stylesheet from the given style data. <cite>styles</cite> can
either be a string containing a stylesheet definition, or an
object containing a <a class="reference internal" href="../CSS-styles.html#css-style-objects"><em>CSS Style Object</em></a>.
For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Styles</span><span class="p">(</span><span class="s2">&quot;body {font-family: serif; font-style: italic}&quot;</span><span class="p">);</span>
</pre></div>
</div>
<p>and</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Styles</span><span class="p">({</span>
<span class="nx">body</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;font-family&quot;</span><span class="o">:</span> <span class="s2">&quot;serif&quot;</span><span class="p">,</span>
<span class="s2">&quot;font-style&quot;</span><span class="o">:</span> <span class="s2">&quot;italic&quot;</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>both set the body font family and style.</p>
<p>The callback routine is called when the stylesheet has been
created and is available for use.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>styles</strong> &#8212; CSS style object for the styles to set</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">Internet Explorer has a limit of 32 dynamically created
stylesheets, so it is best to combine your styles into one
large group rather than making several smaller calls.</p>
</div>
</dd></dl>
<dl class="method">
<dt id="fileURL">
<tt class="descname">fileURL</tt><big>(</big><em>file</em><big>)</big><a class="headerlink" href="#fileURL" title="Permalink to this definition"></a></dt>
<dd><p>Returns a complete URL to a file (replacing <tt class="docutils literal"><span class="pre">[MathJax]</span></tt> with the
actual root URL location).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; the file name possibly including <tt class="docutils literal"><span class="pre">[MathJax]</span></tt></li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the full URL for the file</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Ajax Object</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="hub.html"
title="previous chapter">The MathJax.Hub Object</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="message.html"
title="next chapter">The MathJax.Message Object</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="message.html" title="The MathJax.Message Object"
>next</a> |</li>
<li class="right" >
<a href="hub.html" title="The MathJax.Hub Object"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

521
docs/html/api/callback.html
View File

@ -1,521 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Callback Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Callback.Queue Class" href="queue.html" />
<link rel="prev" title="The MathJax.HTML Object" href="html.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="queue.html" title="The MathJax.Callback.Queue Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="html.html" title="The MathJax.HTML Object"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-callback-class">
<span id="api-callback"></span><h1>The MathJax.Callback Class<a class="headerlink" href="#the-mathjax-callback-class" title="Permalink to this headline"></a></h1>
<p>The <tt class="docutils literal"><span class="pre">MathJax.Callback</span></tt> object is one of the key mechanisms used by
MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A <cite>Callback</cite>
object is used to tie the execution of a function to the completion of
an asynchronous action. See <a class="reference internal" href="../synchronize.html#synchronization"><em>Synchronizing with MathJax</em></a> for more details, and <a class="reference internal" href="../callbacks.html#using-callbacks"><em>Using Callbacks</em></a> in particular for examples of how to specify and
use MathJax <cite>Callback</cite> objects.</p>
<div class="section" id="specifying-a-callback">
<h2>Specifying a callback<a class="headerlink" href="#specifying-a-callback" title="Permalink to this headline"></a></h2>
<p>When a method includes a callback as one of its arguments, that
callback can be specified in a number of different ways, depending on
the functionality that is required of the callback. The easiest case
is to simply provide a function to be called, but it is also possible
to include data to pass to the function when it is executed, and even
the object that will be used as the javascript <cite>this</cite> object when the
function is called.</p>
<p>Most functions that take callbacks as arguments accept a <cite>callback
specification</cite> rather than an actual callback object, though you can
use the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback()</span></tt> function to convert a callback
specification into a Callback object if needed.</p>
<p>A callback specification is any one of the following:</p>
<blockquote>
<div><dl class="describe">
<dt>
<tt class="descname">fn</tt></dt>
<dd><p>A function that is to be called when the callback is executed.
No additional data is passed to it (other than what it is
called with at the time the callback is executed), and <cite>this</cite>
will be the window object.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[fn]</tt></dt>
<dd><p>An array containing a function to be called when the callback
is executed (as above).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[fn, data...]</tt></dt>
<dd><p>An array containing a function together with data to be passed
to that function when the callback is executed; <cite>this</cite> is still
the window object. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[</span><span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">,</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="nx">x</span><span class="o">+</span><span class="nx">y</span><span class="p">},</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</pre></div>
</div>
<p>would specify a callback that would pass <tt class="docutils literal"><span class="pre">2</span></tt> and <tt class="docutils literal"><span class="pre">3</span></tt> to
the given function, and it would return their sum, <tt class="docutils literal"><span class="pre">5</span></tt>, when
the callback is executed.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[object, fn]</tt></dt>
<dd><p>An array containing an object to use as <cite>this</cite> and a function to
call for the callback. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[{</span><span class="nx">x</span><span class="o">:</span><span class="s1">&#39;foo&#39;</span><span class="p">,</span> <span class="nx">y</span><span class="o">:</span><span class="s1">&#39;bar&#39;</span><span class="p">},</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">x</span><span class="p">}]</span>
</pre></div>
</div>
<p>would produce a callback that returns the string <tt class="docutils literal"><span class="pre">&quot;foo&quot;</span></tt>
when it is called.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[object, fn, data...]</tt></dt>
<dd><p>Similar to the previous case, but with data that is passed to
the function as well.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[&quot;method&quot;, object]</tt></dt>
<dd><p>Here, <cite>object</cite> is an object that has a method called <cite>method</cite>, and
the callback will execute that method (with the object as
<cite>this</cite>) when it is called. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[</span><span class="s2">&quot;toString&quot;</span><span class="p">,[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]]</span>
</pre></div>
</div>
<p>would call the <cite>toString</cite> method on the array <tt class="docutils literal"><span class="pre">[1,2,3,4]</span></tt> when
the callback is called, returning <tt class="docutils literal"><span class="pre">1,2,3,4</span></tt>.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">[&quot;method&quot;, object, data...]</tt></dt>
<dd><p>Similar to the previous case, but with data that is passed to
the method. E.g.,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="p">[</span><span class="s2">&quot;slice&quot;</span><span class="p">,[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</pre></div>
</div>
<p>would perform the equivalent of <tt class="docutils literal"><span class="pre">[1,2,3,4].slice(1,3)</span></tt>,
which returns the array <tt class="docutils literal"><span class="pre">[2,3]</span></tt> as a result.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">{hook: fn, data: [...], object: this}</tt></dt>
<dd><p>Here the data for the callback are given in an associative
array of <cite>key:value</cite> pairs. The value of <cite>hook</cite> is the
function to call, the value of <cite>data</cite> is an array of the
arguments to pass to the function, and the value of <cite>object</cite>
is the object to use as <cite>this</cite> in the function call. The
specification need not include all three <cite>key:value</cite> pairs; any
that are missing get default values (a function that does
nothing, an empty array, and the window object, respectively).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">&quot;string&quot;</tt></dt>
<dd><p>This specifies a callback where the string is executed via an
<tt class="docutils literal"><span class="pre">eval()</span></tt> statement. The code is run in the global context,
so any variables or functions created by the string become
part of the global namespace. The return value is the value of
the last statement executed in the string.</p>
</dd></dl>
</div></blockquote>
<div class="section" id="executing-a-callback-object">
<h3>Executing a Callback Object<a class="headerlink" href="#executing-a-callback-object" title="Permalink to this headline"></a></h3>
<p>The <cite>Callback</cite> object is itself a function, and calling that function
executes the callback. You can pass the callback additional
parameters, just as you can any function, and these will be added to
the callback function&#8217;s argument list following any data that was
supplied at the time the callback was created. For example</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">f</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">,</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="nx">x</span> <span class="o">+</span> <span class="s2">&quot; and &quot;</span> <span class="o">+</span><span class="nx">y</span><span class="p">}</span>
<span class="kd">var</span> <span class="nx">cb</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Callback</span><span class="p">([</span><span class="nx">f</span><span class="p">,</span> <span class="s2">&quot;foo&quot;</span><span class="p">]);</span>
<span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">cb</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span> <span class="c1">// sets result to &quot;foo and bar&quot;</span>
</pre></div>
</div>
<p>Usually, the callback is not executed by the code that creates it (as
it is in the example above), but by some other code that runs at a
later time at the completion of some other activity (say the loading
of a file), or in response to a user action. For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">function</span> <span class="nx">f</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;x contains &quot;</span><span class="o">+</span><span class="nx">x</span><span class="p">)};</span>
<span class="kd">function</span> <span class="nx">DelayedX</span><span class="p">(</span><span class="nx">time</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">x</span> <span class="o">=</span> <span class="s2">&quot;hi&quot;</span><span class="p">;</span>
<span class="nx">setTimeout</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Callback</span><span class="p">([</span><span class="nx">f</span><span class="p">,</span> <span class="nx">x</span><span class="p">],</span> <span class="nx">time</span><span class="p">));</span>
<span class="p">}</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">DelayedX</span></tt> function arranges for the function <tt class="docutils literal"><span class="pre">f</span></tt> to be called at
a later time, passing it the value of a local variable, <tt class="docutils literal"><span class="pre">x</span></tt>. Normally,
this would require the use of a closure, but that is not needed when a
<cite>MathJax.Callback</cite> object is used.</p>
</div>
</div>
<div class="section" id="callback-object-properties">
<h2>Callback Object Properties<a class="headerlink" href="#callback-object-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">hook</tt></dt>
<dd><p>The function to be called when the callback is executed.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">data</tt></dt>
<dd><p>An array containing the arguments to pass to the callback
function when it is executed.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">object</tt></dt>
<dd><p>The object to use as <cite>this</cite> during the call to the callback
function.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">called</tt></dt>
<dd><p>Set to <tt class="docutils literal"><span class="pre">true</span></tt> after the callback has been called, and undefined
otherwise. A callback will not be executed a second time unless
the callback&#8217;s <a class="reference internal" href="#reset" title="reset"><tt class="xref py py-meth docutils literal"><span class="pre">reset()</span></tt></a> method is called first, or its
<tt class="docutils literal"><span class="pre">autoReset</span></tt> property is set to <tt class="docutils literal"><span class="pre">true</span></tt>.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">autoReset</tt></dt>
<dd><p>Set this to <tt class="docutils literal"><span class="pre">true</span></tt> if you want to be able to call the callback
more than once. (This is the case for signal listeners, for example).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">isCallback</tt></dt>
<dd><p>Always set to <tt class="docutils literal"><span class="pre">true</span></tt> (used to detect if an object is a callback
or not).</p>
</dd></dl>
</div>
<div class="section" id="callback-object-methods">
<h2>Callback Object Methods<a class="headerlink" href="#callback-object-methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="reset">
<tt class="descname">reset</tt><big>(</big><big>)</big><a class="headerlink" href="#reset" title="Permalink to this definition"></a></dt>
<dd><p>Clears the callback&#8217;s <cite>called</cite> property.</p>
</dd></dl>
</div>
<div class="section" id="mathjax-callback-methods">
<h2>MathJax.Callback Methods<a class="headerlink" href="#mathjax-callback-methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Delay">
<tt class="descname">Delay</tt><big>(</big><em>time</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Delay" title="Permalink to this definition"></a></dt>
<dd><p>Waits for the specified time (given in milliseconds) and then
performs the callback. It returns the Callback object (or a blank
one if none was supplied). The returned callback structure has a
<cite>timeout</cite> property set to the result of the <tt class="docutils literal"><span class="pre">setTimeout()</span></tt> call
that was used to perform the wait so that you can cancel the wait,
if needed. Thus <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback.Delay()</span></tt> can be used to
start a timeout delay that executes the callback if an action
doesn&#8217;t occur within the given time (and if the action does occur,
the timeout can be canceled). Since
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback.Delay()</span></tt> returns a callback structure, it
can be used in a callback queue to insert a delay between queued
commands.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>time</strong> &#8212; the amount of time to wait</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Queue">
<tt class="descname">Queue</tt><big>(</big><span class="optional">[</span><em>callback</em>, <em>...</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Queue" title="Permalink to this definition"></a></dt>
<dd><p>Creates a <cite>MathJax.CallBack.Queue</cite> object and pushes the given
callbacks into the queue. See <a class="reference internal" href="../queues.html#using-queues"><em>Using Queues</em></a>
for more details about MathJax queues.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; one or more callback specifications</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>Queue</cite> object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Signal">
<tt class="descname">Signal</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#Signal" title="Permalink to this definition"></a></dt>
<dd><p>Looks for a named signal, creates it if it doesn&#8217;t already exist,
and returns the signal object. See
<a class="reference internal" href="../signals.html#using-signals"><em>Using Signals</em></a> for more details.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>name</strong> &#8212; name of the signal to get or create</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>Signal</cite> object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="ExecuteHooks">
<tt class="descname">ExecuteHooks</tt><big>(</big><em>hooks</em><span class="optional">[</span>, <em>data</em><span class="optional">[</span>, <em>reset</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#ExecuteHooks" title="Permalink to this definition"></a></dt>
<dd><p>Calls each callback in the <cite>hooks</cite> array (or the single hook if it
is not an array), passing it the arguments stored in the data
array. If <cite>reset</cite> is <tt class="docutils literal"><span class="pre">true</span></tt>, then the callback&#8217;s
<a class="reference internal" href="#reset" title="reset"><tt class="xref py py-meth docutils literal"><span class="pre">reset()</span></tt></a> method will be called before each hook is
executed. If any of the hooks returns a <cite>Callback</cite> object, then
it collects those callbacks and returns a new callback that will
execute when all the ones returned by the hooks have been
completed. Otherwise, <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback.ExecuteHooks()</span></tt>
returns <tt class="docutils literal"><span class="pre">null</span></tt>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>hooks</strong> &#8212; array of hooks to be called, or a hook</li>
<li><strong>data</strong> &#8212; array of arguments to pass to each hook in turn</li>
<li><strong>reset</strong> &#8212; <tt class="docutils literal"><span class="pre">true</span></tt> if the <a class="reference internal" href="#reset" title="reset"><tt class="xref py py-meth docutils literal"><span class="pre">reset()</span></tt></a> method should be called</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">callback that waits for all the hooks to complete, or <tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Hooks">
<tt class="descname">Hooks</tt><big>(</big><em>reset</em><big>)</big><a class="headerlink" href="#Hooks" title="Permalink to this definition"></a></dt>
<dd><p>Creates a prioritized list of hooks that are called in order based
on their priority (low priority numbers are handled first). This
is meant to replace <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback.ExecuteHooks()</span></tt> and is
used internally for signal callbacks, pre- and post-filters, and
other lists of callbacks.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>reset</strong> &#8212; <tt class="docutils literal"><span class="pre">true</span></tt> if callbacks can be called more than once</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>Hooks</cite> object</p>
</td>
</tr>
</tbody>
</table>
<p>The list has the following methods:</p>
<dl class="method">
<dt id="Add">
<tt class="descname">Add</tt><big>(</big><em>hook</em><span class="optional">[</span>, <em>priority</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Add" title="Permalink to this definition"></a></dt>
<dd><p>Add a callback to the prioritized list. If <tt class="docutils literal"><span class="pre">priority</span></tt> is
not provided, the default is 10. The <tt class="docutils literal"><span class="pre">hook</span></tt> is a <cite>Callback</cite>
specification as described above.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>hook</strong> &#8212; callback specification to add to the list</li>
<li><strong>priority</strong> &#8212; priority of the hook in the list (default: 10)</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object being added</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Remove</tt><big>(</big><em>hook</em><big>)</big></dt>
<dd><p>Remove a given hook (as returned from <a class="reference internal" href="#Add" title="Add"><tt class="xref py py-meth docutils literal"><span class="pre">Add()</span></tt></a> above)
from the prioritized list.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>hook</strong> &#8212; the callback to be removed</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Execute">
<tt class="descname">Execute</tt><big>(</big><big>)</big><a class="headerlink" href="#Execute" title="Permalink to this definition"></a></dt>
<dd><p>Execute the list of callbacks, resetting them if requested.
If any of the hooks return callbacks, then <tt class="docutils literal"><span class="pre">Execute()</span></tt>
returns a callback that will be executed when they all have
completed.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body">a callback object or <tt class="docutils literal"><span class="pre">null</span></tt></td>
</tr>
</tbody>
</table>
</dd></dl>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Callback Class</a><ul>
<li><a class="reference internal" href="#specifying-a-callback">Specifying a callback</a><ul>
<li><a class="reference internal" href="#executing-a-callback-object">Executing a Callback Object</a></li>
</ul>
</li>
<li><a class="reference internal" href="#callback-object-properties">Callback Object Properties</a></li>
<li><a class="reference internal" href="#callback-object-methods">Callback Object Methods</a></li>
<li><a class="reference internal" href="#mathjax-callback-methods">MathJax.Callback Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="html.html"
title="previous chapter">The MathJax.HTML Object</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="queue.html"
title="next chapter">The MathJax.Callback.Queue Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="queue.html" title="The MathJax.Callback.Queue Class"
>next</a> |</li>
<li class="right" >
<a href="html.html" title="The MathJax.HTML Object"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

321
docs/html/api/elementjax.html
View File

@ -1,321 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.ElementJax Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The Base Jax Class" href="jax.html" />
<link rel="prev" title="The MathJax.OutputJax Class" href="outputjax.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="jax.html" title="The Base Jax Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="outputjax.html" title="The MathJax.OutputJax Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-elementjax-class">
<span id="api-element-jax"></span><h1>The MathJax.ElementJax Class<a class="headerlink" href="#the-mathjax-elementjax-class" title="Permalink to this headline"></a></h1>
<p>The element jax is the bridge between the input and output jax, and
contains the data produced by the input jax needed by the output jax
to display the results. It is tied to the individual <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag
that produced it, and is the object used by JavaScript programs to
interact with the mathematics on the page.</p>
<p>An element jax is stored in the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file in a subdirectory of
the <tt class="docutils literal"><span class="pre">jax/element</span></tt> directory, with the subdirectory name being the
name of the element jax. Currently, there is only one element jax
class, the <cite>mml</cite> element jax, and it is stored in <tt class="docutils literal"><span class="pre">jax/element/mml</span></tt>.</p>
<p>The <cite>MathJax.ElementJax</cite> class is a subclass of the <a class="reference internal" href="jax.html#api-jax"><em>MathJax Jax</em></a> class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.</p>
<div class="section" id="class-properties">
<h2>Class Properties<a class="headerlink" href="#class-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">id</tt></dt>
<dd><p>The name of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">version</tt></dt>
<dd><p>The version number of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">directory</tt></dt>
<dd><p>The directory where the jax files are stored (e.g., <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax/element/mml&quot;</span></tt>).</p>
</dd></dl>
</div>
<div class="section" id="instance-properties">
<h2>Instance Properties<a class="headerlink" href="#instance-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">inputJax</tt></dt>
<dd><p>The name of the input jax that created the element.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">outputJax</tt></dt>
<dd><p>The name of the output jax that has processed this element.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">inputID</tt></dt>
<dd><p>The DOM <cite>id</cite> of the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag that generated this element
(if it doesn&#8217;t have one initially, the MathJax hub will supply
one). Note that this is not a reference to the element itself;
that element will have a reference to this element jax, and if
<cite>inputID</cite> were a reference back, that would cause a reference
loop, which some browsers would not free properly during trash
collection, thus causing a memory leak.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">originalText</tt></dt>
<dd><p>A string indicating the original input text that was processed for
this element. (In the future, this may be managed by the input jax
rather than <tt class="docutils literal"><span class="pre">MathJax.Hub</span></tt>.)</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">mimeType</tt></dt>
<dd><p>The MIME-type of the element jax (<cite>jax/mml</cite> in the case of an
<cite>mml</cite> element jax).</p>
</dd></dl>
<p>Other data specific to the element jax subclass may also appear here.</p>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Text">
<tt class="descname">Text</tt><big>(</big><em>text</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Text" title="Permalink to this definition"></a></dt>
<dd><p>Sets the input text for this element to the given text and
reprocesses the mathematics. (I.e., updates the equation to the
new one given by <cite>text</cite>). When the processing is complete, the
<cite>callback</cite>, if any, is called.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>text</strong> &#8212; the new mathematics source string for the element</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Rerender</tt><big>(</big><span class="optional">[</span><em>callback</em><span class="optional">]</span><big>)</big></dt>
<dd><p>Removes the output and produces it again (for example, if CSS has
changed that would alter the spacing of the mathematics). Note
that the internal representation isn&#8217;t regenerated; only the
output is. The <cite>callback</cite>, if any, is called when the process
completes.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Reprocess</tt><big>(</big><span class="optional">[</span><em>callback</em><span class="optional">]</span><big>)</big></dt>
<dd><p>Removes the output and then retranslates the input into the
internal form and reredners the output again. The <cite>callback</cite>, if
any, is called when the process completes.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Remove</tt><big>(</big><big>)</big></dt>
<dd><p>Removes the output for this element from the web page (but does
not remove the original <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt>). The <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> will be
considered unprocessed, and the next call to
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.hub.Typeset()</span></tt> will re-display it.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><tt class="docutils literal"><span class="pre">null</span></tt></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="SourceElement">
<tt class="descname">SourceElement</tt><big>(</big><big>)</big><a class="headerlink" href="#SourceElement" title="Permalink to this definition"></a></dt>
<dd><p>Returns a reference to the original <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> DOM element
associated to this element jax.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body">the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> element</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="needsUpdate">
<tt class="descname">needsUpdate</tt><big>(</big><big>)</big><a class="headerlink" href="#needsUpdate" title="Permalink to this definition"></a></dt>
<dd><p>Indicates whether the mathematics has changed so that its output
needs to be updated.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><tt class="docutils literal"><span class="pre">true</span></tt> if the mathematics needs to be reprocessed,
<tt class="docutils literal"><span class="pre">false</span></tt> otherwise</td>
</tr>
</tbody>
</table>
</dd></dl>
<p>Output jax may add new methods to the base element jax class to
perform exporting to other formats. For example, a MathML output jax
could add <tt class="docutils literal"><span class="pre">toMathML()</span></tt>, or an accessibility output jax could add
<tt class="docutils literal"><span class="pre">toAudible()</span></tt>. These could be made available via the MathJax
contextual menu.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.ElementJax Class</a><ul>
<li><a class="reference internal" href="#class-properties">Class Properties</a></li>
<li><a class="reference internal" href="#instance-properties">Instance Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="outputjax.html"
title="previous chapter">The MathJax.OutputJax Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="jax.html"
title="next chapter">The Base Jax Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="jax.html" title="The Base Jax Class"
>next</a> |</li>
<li class="right" >
<a href="outputjax.html" title="The MathJax.OutputJax Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

334
docs/html/api/html.html
View File

@ -1,334 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.HTML Object &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Callback Class" href="callback.html" />
<link rel="prev" title="The MathJax.Message Object" href="message.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="callback.html" title="The MathJax.Callback Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="message.html" title="The MathJax.Message Object"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-html-object">
<span id="api-html"></span><h1>The MathJax.HTML Object<a class="headerlink" href="#the-mathjax-html-object" title="Permalink to this headline"></a></h1>
<p>The <tt class="docutils literal"><span class="pre">MathJax.HTML</span></tt> object provides routines for creating HTML
elements and adding them to the page, and in particular, it contains
the code that processes MathJax&#8217;s <a class="reference internal" href="../HTML-snippets.html#html-snippets"><em>HTML snippets</em></a>
and turns them into actual DOM objects. It also implements the
methods used to manage the cookies used by MathJax.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">Cookie.prefix: &quot;mjx&quot;</tt></dt>
<dd><p>The prefix used for names of cookies stored by MathJax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Cookie.expires: 365</tt></dt>
<dd><p>The expiration time (in days) for cookies created by MathJax.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Element">
<tt class="descname">Element</tt><big>(</big><em>type</em><span class="optional">[</span>, <em>attributes</em><span class="optional">[</span>, <em>contents</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Element" title="Permalink to this definition"></a></dt>
<dd><p>Creates a DOM element of the given type. If <cite>attributes</cite> is
non-<tt class="docutils literal"><span class="pre">null</span></tt>, it is an object that contains <cite>key:value</cite> pairs of
attributes to set for the newly created element. If <cite>contents</cite> is
non-<tt class="docutils literal"><span class="pre">null</span></tt>, it is an <a class="reference internal" href="../HTML-snippets.html#html-snippets"><em>HTML snippet</em></a> that
describes the contents to create for the element. For example</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">div</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">HTML</span><span class="p">.</span><span class="nx">Element</span><span class="p">(</span>
<span class="s2">&quot;div&quot;</span><span class="p">,</span>
<span class="p">{</span><span class="nx">id</span><span class="o">:</span> <span class="s2">&quot;MathDiv&quot;</span><span class="p">,</span> <span class="nx">style</span><span class="o">:</span><span class="p">{</span><span class="nx">border</span><span class="o">:</span><span class="s2">&quot;1px solid&quot;</span><span class="p">,</span> <span class="nx">padding</span><span class="o">:</span><span class="s2">&quot;5px&quot;</span><span class="p">}},</span>
<span class="p">[</span><span class="s2">&quot;Here is math: \\(x+1\\)&quot;</span><span class="p">,[</span><span class="s2">&quot;br&quot;</span><span class="p">],</span><span class="s2">&quot;and a display $$x+1\\over x-1$$&quot;</span><span class="p">]</span>
<span class="p">);</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>type</strong> &#8212; node type to be created</li>
<li><strong>attributes</strong> &#8212; object specifying attributes to set</li>
<li><strong>contents</strong> &#8212; HTML snippet representing contents of node</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the DOM element created</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="addElement">
<tt class="descname">addElement</tt><big>(</big><em>parent</em>, <em>type</em><span class="optional">[</span>, <em>attributes</em><span class="optional">[</span>, <em>content</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#addElement" title="Permalink to this definition"></a></dt>
<dd><p>Creates a DOM element and appends it to the <cite>parent</cite> node
provided. It is equivalent to</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">parent</span><span class="p">.</span><span class="nx">appendChild</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">HTML</span><span class="p">.</span><span class="nx">Element</span><span class="p">(</span><span class="nx">type</span><span class="p">,</span><span class="nx">attributes</span><span class="p">,</span><span class="nx">content</span><span class="p">))</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>parent</strong> &#8212; the node where the element will be added</li>
<li><strong>attributes</strong> &#8212; object specifying attributes to set</li>
<li><strong>contents</strong> &#8212; HTML snippet representing contents of node</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the DOM element created</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="TextNode">
<tt class="descname">TextNode</tt><big>(</big><em>text</em><big>)</big><a class="headerlink" href="#TextNode" title="Permalink to this definition"></a></dt>
<dd><p>Creates a DOM text node with the given text as its content.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>text</strong> &#8212; the text for the node</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the new text node</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="addText">
<tt class="descname">addText</tt><big>(</big><em>parent</em>, <em>text</em><big>)</big><a class="headerlink" href="#addText" title="Permalink to this definition"></a></dt>
<dd><p>Creates a DOM text node with the given text and appends it to the
<cite>parent</cite> node.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>parent</strong> &#8212; the node where the text will be added</li>
<li><strong>text</strong> &#8212; the text for the new node</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the new text node</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="setScript">
<tt class="descname">setScript</tt><big>(</big><em>script</em>, <em>text</em><big>)</big><a class="headerlink" href="#setScript" title="Permalink to this definition"></a></dt>
<dd><p>Sets the contents of the <tt class="docutils literal"><span class="pre">script</span></tt> element to be the given
<tt class="docutils literal"><span class="pre">text</span></tt>, properly taking into account the browser limitations and
bugs.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>script</strong> &#8212; the script whose content is to be set</li>
<li><strong>text</strong> &#8212; the text that is to be the script&#8217;s new content</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="getScript">
<tt class="descname">getScript</tt><big>(</big><em>script</em><big>)</big><a class="headerlink" href="#getScript" title="Permalink to this definition"></a></dt>
<dd><p>Gets the contents of the <tt class="docutils literal"><span class="pre">script</span></tt> element, properly taking into
account the browser limitations and bugs.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>script</strong> &#8212; the script whose content is to be retrieved</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the text of the <tt class="docutils literal"><span class="pre">script</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Cookie.Set(name,data)</tt></dt>
<dd><p>Creates a MathJax cookie using the <tt class="docutils literal"><span class="pre">MathJax.HTML.Cookie.prefix</span></tt>
and the <cite>name</cite> as the cookie name, and the <cite>key:value</cite> pairs in
the <cite>data</cite> object as the data for the cookie. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">HTML</span><span class="p">.</span><span class="nx">Cookie</span><span class="p">.</span><span class="nx">Set</span><span class="p">(</span><span class="s2">&quot;test&quot;</span><span class="p">,{</span><span class="nx">x</span><span class="o">:</span><span class="mi">42</span><span class="p">,</span> <span class="nx">y</span><span class="o">:</span><span class="s2">&quot;It Works!&quot;</span><span class="p">});</span>
</pre></div>
</div>
<p>will create a cookie named &#8220;mjx.test&#8221; that stores the values of
<tt class="docutils literal"><span class="pre">x</span></tt> and <tt class="docutils literal"><span class="pre">y</span></tt> provided in the <cite>data</cite> object. This data can be
retrieved using the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.HTML.Cookie.Get()</span></tt> method
discussed below.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>name</strong> &#8212; the name that identifies the cookie</li>
<li><strong>data</strong> &#8212; object containing the data to store in the cookie</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Cookie.Get(name[,obj])</tt></dt>
<dd><p>Looks up the data for the cookie named <cite>name</cite> and merges the data
into the given <cite>obj</cite> object, or returns a new object containing
the data. For instance, given the cookie stored by the example
above,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">data</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">HTML</span><span class="p">.</span><span class="nx">Cookie</span><span class="p">.</span><span class="nx">Get</span><span class="p">(</span><span class="s2">&quot;test&quot;</span><span class="p">);</span>
</pre></div>
</div>
<p>would set <tt class="docutils literal"><span class="pre">data</span></tt> to <tt class="docutils literal"><span class="pre">{x:42,</span> <span class="pre">y:&quot;It</span> <span class="pre">Works!&quot;}</span></tt>, while</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">data</span> <span class="o">=</span> <span class="p">{</span><span class="nx">x</span><span class="o">:</span><span class="mi">10</span><span class="p">,</span> <span class="nx">z</span><span class="o">:</span><span class="s2">&quot;Safe&quot;</span><span class="p">};</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">HTML</span><span class="p">.</span><span class="nx">Cookie</span><span class="p">.</span><span class="nx">Get</span><span class="p">(</span><span class="s2">&quot;test&quot;</span><span class="p">,</span><span class="nx">data</span><span class="p">);</span>
</pre></div>
</div>
<p>would leave <tt class="docutils literal"><span class="pre">data</span></tt> as <tt class="docutils literal"><span class="pre">{x:42,</span> <span class="pre">y:&quot;It</span> <span class="pre">Works!&quot;,</span> <span class="pre">z:&quot;Safe&quot;}</span></tt>.</p>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.HTML Object</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="message.html"
title="previous chapter">The MathJax.Message Object</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="callback.html"
title="next chapter">The MathJax.Callback Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="callback.html" title="The MathJax.Callback Class"
>next</a> |</li>
<li class="right" >
<a href="message.html" title="The MathJax.Message Object"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

789
docs/html/api/hub.html
View File

@ -1,789 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Hub Object &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Ajax Object" href="ajax.html" />
<link rel="prev" title="The MathJax variable" href="variable.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="ajax.html" title="The MathJax.Ajax Object"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="variable.html" title="The MathJax variable"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-hub-object">
<span id="api-hub"></span><h1>The MathJax.Hub Object<a class="headerlink" href="#the-mathjax-hub-object" title="Permalink to this headline"></a></h1>
<p>The MathJax Hub, <cite>MathJax.Hub</cite>, is the main control structure for
MathJax. It is where input and output <a class="reference internal" href="../glossary.html#term-jax"><em class="xref std std-term">jax</em></a> are tied together,
and it is what handles processing of the MathJax <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tags.
Processing of the mathematics on the page may require external files
to be loaded (when the mathematics includes less common functionality,
for example, that is defined in an extension file), and since file
loading is asynchronous, a number of the methods below may return
before their actions are completed. For this reason, they include
callback functions that are called when the action completes. These
can be used to synchronize actions that require the mathematics to be
completed before those actions occur. See the <a class="reference internal" href="../callbacks.html#using-callbacks"><em>Using Callbacks</em></a> documentation for more details.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">config: { ... }</tt></dt>
<dd><p>This holds the configuration parameters for MathJax. Set these
values using <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Hub.Config()</span></tt> described below. The
options and their default values are given in the <a class="reference internal" href="../options/hub.html#configure-hub"><em>Core
Options</em></a> reference page.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">processUpdateTime: 250</tt></dt>
<dd><p>The minimum time (in milliseconds) between updates of the
&#8220;Processing Math&#8221; message. After this amount of time has passed,
and after the next equation has finished being processed,
MathJax will stop processing momentarily so that the update
message can be displayed, and so that the browser can handle user
interaction.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">processUpdateDelay: 10</tt></dt>
<dd><p>The amount of time (in milliseconds) that MathJax pauses after
issuing its processing message before starting the processing again
(to give browsers time to handle user interaction).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">signal</tt></dt>
<dd><p>The hub processing signal (tied to the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Hub.Register.MessageHook()</span></tt> method).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">queue</tt></dt>
<dd><p>MathJax&#8217;s main processing queue. Use <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Hub.Queue()</span></tt> to push
callbacks onto this queue.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Browser</tt></dt>
<dd><p>The name of the browser as determined by MathJax. It will be one
of <tt class="docutils literal"><span class="pre">Firefox</span></tt>, <tt class="docutils literal"><span class="pre">Safari</span></tt>, <tt class="docutils literal"><span class="pre">Chrome</span></tt>, <tt class="docutils literal"><span class="pre">Opera</span></tt>, <tt class="docutils literal"><span class="pre">MSIE</span></tt>,
<tt class="docutils literal"><span class="pre">Konqueror</span></tt>, or <tt class="docutils literal"><span class="pre">unkown</span></tt>. This is actually an object with
additional properties and methods concerning the browser:</p>
<dl class="describe">
<dt>
<tt class="descname">version</tt></dt>
<dd><p>The browser version number, e.g., <tt class="docutils literal"><span class="pre">&quot;4.0&quot;</span></tt></p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">isMac and isPC</tt></dt>
<dd><p>These are boolean values that indicate whether the browser is
running on a Macintosh computer or a Windows computer. They
will both be <tt class="docutils literal"><span class="pre">false</span></tt> for a Linux computer.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">isMobile</tt></dt>
<dd><p>This is <tt class="docutils literal"><span class="pre">true</span></tt> when MathJax is running a mobile version of a
WebKit or Gecko-based browser.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">isFirefox, isSafari, isChrome, isOpera, isMSIE, isKonqueror</tt></dt>
<dd><p>These are <tt class="docutils literal"><span class="pre">true</span></tt> when the browser is the indicated one, and
<tt class="docutils literal"><span class="pre">false</span></tt> otherwise.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">versionAtLeast(version)</tt></dt>
<dd><p>This tests whether the browser version is at least that given
in the <cite>version</cite> string. Note that you can not simply do a
numeric comparison, as version 4.10 should be considered later
than 4.9, for example. Similarly, 4.10 is different from 4.1,
for instance.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Select(choices)</tt></dt>
<dd><p>This lets you perform browser-specific functions. Here,
<cite>choices</cite> is an object whose properties are the names of the
browsers and whose values are the functions to be performed.
Each function is passed one parameter, which is the
<tt class="docutils literal"><span class="pre">MathJax.Hub.Browser</span></tt> object. You do not need to include
every browser as one of your choices &#8212; only those for which you
need to do special processing. For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Browser</span><span class="p">.</span><span class="nx">Select</span><span class="p">(</span>
<span class="nx">MSIE</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">browser</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">browser</span><span class="p">.</span><span class="nx">versionAtLeast</span><span class="p">(</span><span class="s2">&quot;8.0&quot;</span><span class="p">))</span> <span class="p">{...</span> <span class="k">do</span> <span class="nx">version</span> <span class="mi">8</span> <span class="nx">stuff</span> <span class="p">...</span> <span class="p">}</span>
<span class="p">...</span> <span class="k">do</span> <span class="nx">general</span> <span class="nx">MSIE</span> <span class="nx">stuff</span> <span class="p">...</span>
<span class="p">},</span>
<span class="nx">Firefox</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">browser</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">browser</span><span class="p">.</span><span class="nx">isMac</span><span class="p">)</span> <span class="p">{...</span> <span class="k">do</span> <span class="nx">Mac</span> <span class="nx">stuff</span> <span class="p">...</span> <span class="p">}</span>
<span class="p">...</span> <span class="k">do</span> <span class="nx">general</span> <span class="nx">Firefox</span> <span class="nx">stuff</span>
<span class="p">}</span>
<span class="p">);</span>
</pre></div>
</div>
</dd></dl>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">inputJax</tt></dt>
<dd><p>An object storing the MIME types associated with the various
registered input jax (these are the types of the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tags
that store the math to be processed by each input jax).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">outputJax</tt></dt>
<dd><p>An object storing the output jax associate with the various
element jax MIME types for the registered output jax.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Config">
<tt class="descname">Config</tt><big>(</big><em>options</em><big>)</big><a class="headerlink" href="#Config" title="Permalink to this definition"></a></dt>
<dd><p>Sets the configuration options (stored in <tt class="docutils literal"><span class="pre">MathJax.Hub.config</span></tt>)
to the values stored in the <cite>options</cite> object. See
<a class="reference internal" href="../options/index.html#configuration"><em>Configuring MathJax</em></a> for details on how this
is used and the options that you can set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>options</strong> &#8212; object containing options to be set</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Configured()</tt></dt>
<dd><p>When <tt class="docutils literal"><span class="pre">delayStartupUntil</span></tt> is specified in the configuration file or
in the script that loads <tt class="docutils literal"><span class="pre">MathJax.js</span></tt>, MathJax&#8217;s startup sequence is
delayed until this routine is called. See <a class="reference internal" href="../options/index.html#configuration"><em>Configuring MathJax</em></a> for details on how this is used.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><tt class="docutils literal"><span class="pre">null</span></tt></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Register.PreProcessor(callback)</tt></dt>
<dd><p>Used by preprocessors to register themselves with MathJax so that
they will be called during the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Hub.PreProcess()</span></tt>
action.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the callback specification for the preprocessor</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Register.MessageHook(type,callback)</tt></dt>
<dd><p>Registers a listener for a particular message being sent to the
hub processing signal (where <cite>PreProcessing</cite>, <cite>Processing</cite>, and
<cite>New Math</cite> messages are sent). When the message equals the
<cite>type</cite>, the <cite>callback</cite> will be called with the message as its
parameter.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>type</strong> &#8212; a string indicating the message to look for</li>
<li><strong>callback</strong> &#8212; a callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Register.StartupHook(type,callback)</tt></dt>
<dd><p>Registers a listener for a particular message being sent to the
startup signal (where initialization and component startup
messages are sent). When the message equals the <cite>type</cite>, the
<cite>callback</cite> will be called with the message as its parameter.
See the <a class="reference internal" href="../signals.html#using-signals"><em>Using Signals</em></a> documentation for
more details.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>type</strong> &#8212; a string indicating the message to look for</li>
<li><strong>callback</strong> &#8212; a callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">Register.LoadHook(file,callback)</tt></dt>
<dd><p>Registers a callback to be called when a particular file is
completely loaded and processed. (The callback is called when the
file makes its <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.loadComplete()</span></tt> call.) The
<cite>file</cite> should be the complete file name, e.g.,
<tt class="docutils literal"><span class="pre">&quot;[MathJax]/config/default.js&quot;</span></tt>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; the name of the file to wait for</li>
<li><strong>callback</strong> &#8212; a callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Queue</tt><big>(</big><em>callback</em>, <em>...</em><big>)</big></dt>
<dd><p>Pushes the given callbacks onto the main MathJax command queue.
This synchronizes the commands with MathJax so that they will be
performed in the proper order even when some run asynchronously.
See <a class="reference internal" href="../queues.html#using-queues"><em>Using Queues</em></a> for more details about how
to use queues, and the MathJax queue in particular. You may
supply as many <cite>callback</cite> specifications in one call to the
<a class="reference internal" href="callback.html#Queue" title="Queue"><tt class="xref py py-meth docutils literal"><span class="pre">Queue()</span></tt></a> method as you wish.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; a callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object for the last callback added to the queue</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Typeset">
<tt class="descname">Typeset</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Typeset" title="Permalink to this definition"></a></dt>
<dd><p>Calls the preprocessors on the given element (or elements if it is an
array of elements), and then typesets any math elements within the
element. If no <cite>element</cite> is provided, the whole document is processed.
The <cite>element</cite> is either the DOM <cite>id</cite> of the element, a reference to
the DOM element itself, or an array of id&#8217;s or refereneces. The
<cite>callback</cite> is called when the process is complete. See the
<a class="reference internal" href="../typeset.html#typeset-math"><em>Modifying Math</em></a> section for details of how to use
this method properly.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element(s) whose math is to be typeset</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="PreProcess">
<tt class="descname">PreProcess</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#PreProcess" title="Permalink to this definition"></a></dt>
<dd><p>Calls the loaded preprocessors on the entire document, or on the given
DOM element (or elements, if it is an array of elements). The
<cite>element</cite> is either the DOM <cite>id</cite> of the element, a reference to the
DOM element itself, or an array of id&#8217;s or references. The <cite>callback</cite>
is called when the processing is complete.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element to be preprocessed</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Process">
<tt class="descname">Process</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Process" title="Permalink to this definition"></a></dt>
<dd><p>Scans either the entire document or a given DOM <cite>element</cite> (or array of
elements) for MathJax <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tags and processes the math those
tags contain. The <cite>element</cite> is either the DOM <cite>id</cite> of the element to
scan, a reference to the DOM element itself, or an array of id&#8217;s or
references. The <cite>callback</cite> is called when the processing is complete.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element(s) to be processed</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Update">
<tt class="descname">Update</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Update" title="Permalink to this definition"></a></dt>
<dd><p>Scans either the entire document or a given DOM element (or elements if
it is an array of elements) for mathematics that has changed since the
last time it was processed, or is new, and typesets the mathematics
they contain. The <cite>element</cite> is either the DOM <cite>id</cite> of the element to
scan, a reference to the DOM element itself, or an array of id&#8217;s or
references. The <cite>callback</cite> is called when the processing is complete.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element(s) to be updated</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Reprocess">
<tt class="descname">Reprocess</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Reprocess" title="Permalink to this definition"></a></dt>
<dd><p>Removes any typeset mathematics from the document or DOM element
(or elements if it is an array of elements), and then processes
the mathematics again, re-typesetting everything. This may be
necessary, for example, if the CSS styles have changed and those
changes would affect the mathematics. Reprocess calls both the
input and output jax to completely rebuild the data for
mathematics. The <cite>element</cite> is either the DOM <cite>id</cite> of the element
to scan, a reference to the DOM element itself, or an array of
id&#8217;s or references. The <cite>callback</cite> is called when the processing
is complete.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element(s) to be reprocessed</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Rerender">
<tt class="descname">Rerender</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Rerender" title="Permalink to this definition"></a></dt>
<dd><p>Removes any typeset mathematics from the document or DOM element
(or elements if it is an array of elements), and then renders the
mathematics again, re-typesetting everything from the current
internal version (without calling the input jax again). The
<cite>element</cite> is either the DOM <cite>id</cite> of the element to scan, a
reference to the DOM element itself, or an array of id&#8217;s or
references. The <cite>callback</cite> is called when the processing is
complete.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element(s) to be reprocessed</li>
<li><strong>callback</strong> &#8212; the callback specification</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="getAllJax">
<tt class="descname">getAllJax</tt><big>(</big><span class="optional">[</span><em>element</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#getAllJax" title="Permalink to this definition"></a></dt>
<dd><p>Returns a list of all the element jax in the document or a
specific DOM element. The <cite>element</cite> is either the DOM <cite>id</cite> of the
element, or a reference to the DOM element itself.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element to be searched</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">array of <cite>element jax</cite> objects</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="getJaxByType">
<tt class="descname">getJaxByType</tt><big>(</big><em>type</em><span class="optional">[</span>, <em>element</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#getJaxByType" title="Permalink to this definition"></a></dt>
<dd><p>Returns a list of all the element jax of a given MIME-type in the
document or a specific DOM element. The <cite>element</cite> is either the
DOM <cite>id</cite> of the element to search, or a reference to the DOM
element itself.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>type</strong> &#8212; MIME-type of <cite>element jax</cite> to find</li>
<li><strong>element</strong> &#8212; the element to be searched</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">array of <cite>element jax</cite> objects</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="getJaxByInputType">
<tt class="descname">getJaxByInputType</tt><big>(</big><em>type</em><span class="optional">[</span>, <em>element</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#getJaxByInputType" title="Permalink to this definition"></a></dt>
<dd><p>Returns a list of all the element jax associated with input
<tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tags with the given MIME-type within the given DOM
element or the whole document. The <cite>element</cite> is either the DOM
<cite>id</cite> of the element to search, or a reference to the DOM element
itself.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>type</strong> &#8212; MIME-type of input (e.g., <tt class="docutils literal"><span class="pre">&quot;math/tex&quot;</span></tt>)</li>
<li><strong>element</strong> &#8212; the element to be searched</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">array of <cite>element jax</cite> objects</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="getJaxFor">
<tt class="descname">getJaxFor</tt><big>(</big><em>element</em><big>)</big><a class="headerlink" href="#getJaxFor" title="Permalink to this definition"></a></dt>
<dd><p>Returns the element jax associated with a given DOM
element. If the element does not have an associated element jax,
<tt class="docutils literal"><span class="pre">null</span></tt> is returned. The <cite>element</cite> is either the DOM <cite>id</cite> of the
element, or a reference to the DOM element itself.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element whose element jax is required</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><cite>element jax</cite> object or <tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="isJax">
<tt class="descname">isJax</tt><big>(</big><em>element</em><big>)</big><a class="headerlink" href="#isJax" title="Permalink to this definition"></a></dt>
<dd><p>Returns <tt class="docutils literal"><span class="pre">0</span></tt> if the element is not a <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> that can be
processed by MathJax or the result of an output jax, returns <tt class="docutils literal"><span class="pre">-1</span></tt>
if the element is an unprocessed <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag that could be
handled by MathJax, and returns <tt class="docutils literal"><span class="pre">1</span></tt> if the element is a processed
<tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag or an element that is the result of an output jax.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>element</strong> &#8212; the element to inspect</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">integer (-1, 0, 1)</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="setRenderer">
<tt class="descname">setRenderer</tt><big>(</big><em>renderer</em><span class="optional">[</span>, <em>type</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#setRenderer" title="Permalink to this definition"></a></dt>
<dd><p>Sets the output jax for the given element jax <tt class="docutils literal"><span class="pre">type</span></tt> (or <tt class="docutils literal"><span class="pre">jax/mml</span></tt>
if none is specified) to be the one given by <tt class="docutils literal"><span class="pre">renderer</span></tt>, which
must be the name of a renderer, such as <tt class="docutils literal"><span class="pre">NativeMML</span></tt> or
<tt class="docutils literal"><span class="pre">HTML-CSS</span></tt>. Note that this does not cause the math on the page
to be rerendered; it just sets the renderer for output in the
future (call :meth:<tt class="docutils literal"><span class="pre">Rerender()</span></tt> above to replace the current
renderings by new ones).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>renderer</strong> &#8212; the name of the output jax to use for rendering</li>
<li><strong>type</strong> &#8212; the element jax MIME type whose renderer to set</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Insert">
<tt class="descname">Insert</tt><big>(</big><em>dst</em>, <em>src</em><big>)</big><a class="headerlink" href="#Insert" title="Permalink to this definition"></a></dt>
<dd><p>Inserts data from the <cite>src</cite> object into the <cite>dst</cite> object. The
<cite>key:value</cite> pairs in <cite>src</cite> are (recursively) copied into <cite>dst</cite>, so
that if <cite>value</cite> is itself an object, its content is copied into
the corresponding object in <cite>dst</cite>. That is, objects within <cite>src</cite>
are merged into the corresponding objects in <cite>dst</cite> (they don&#8217;t
replace them).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>dst</strong> &#8212; the destination object</li>
<li><strong>src</strong> &#8212; the source object</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the modified destination object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="formatError">
<tt class="descname">formatError</tt><big>(</big><em>script</em>, <em>error</em><big>)</big><a class="headerlink" href="#formatError" title="Permalink to this definition"></a></dt>
<dd><p>This is called when an internal error occurs during the processing
of a math element (i.e., an error in the MathJax code itself).
The <cite>script</cite> is a reference to the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag where the
error occurred, and <cite>error</cite> is the <tt class="docutils literal"><span class="pre">Error</span></tt> object for the error.
The default action is to insert an HTML snippet at the location of
the script, but this routine can be overriden during MathJax
configuration in order to perform some other action.
<tt class="docutils literal"><span class="pre">MathJax.Hub.lastError</span></tt> holds the <tt class="docutils literal"><span class="pre">error</span></tt> value of the last
error on the page.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>script</strong> &#8212; the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag causing the error</li>
<li><strong>error</strong> &#8212; the <tt class="docutils literal"><span class="pre">Error</span></tt> object for the error</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Hub Object</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="variable.html"
title="previous chapter">The MathJax variable</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="ajax.html"
title="next chapter">The MathJax.Ajax Object</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="ajax.html" title="The MathJax.Ajax Object"
>next</a> |</li>
<li class="right" >
<a href="variable.html" title="The MathJax variable"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

144
docs/html/api/index.html
View File

@ -1,144 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax API &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="next" title="The MathJax variable" href="variable.html" />
<link rel="prev" title="Modifying Math on the Page" href="../typeset.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="variable.html" title="The MathJax variable"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="../typeset.html" title="Modifying Math on the Page"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-api">
<span id="mathjax-api"></span><h1>The MathJax API<a class="headerlink" href="#the-mathjax-api" title="Permalink to this headline"></a></h1>
<p>The following links document the various components that make up
MathJax. These are implemented as JavaScript objects contained within
the single global variable, <tt class="docutils literal"><span class="pre">MathJax</span></tt>. Although JavaScript includes
an object system with some inheritance capabilities, they do not
constitute a full object-oriented programming model, so MathJax
implements its own object library. This means there is an ambiguity
when we speak of an &#8220;object&#8221;, as it could be either a native
JavaScript object, or a MathJax object. When the distinction is
importat, we will use <cite>Object</cite> (capitalized) or <cite>MathJax.Object</cite> for
the latter; the javascript object will always be listed in lower
case.</p>
<p>You may also want to view the <a class="reference internal" href="../index.html#advanced-topics"><em>advanced topics</em></a>
on the main MathJax documentation page.</p>
<div class="toctree-wrapper compound">
<ul>
<li class="toctree-l1"><a class="reference internal" href="variable.html">The MathJax variable</a></li>
<li class="toctree-l1"><a class="reference internal" href="hub.html">The MathJax.Hub object</a></li>
<li class="toctree-l1"><a class="reference internal" href="ajax.html">The MathJax.Ajax object</a></li>
<li class="toctree-l1"><a class="reference internal" href="message.html">The MathJax.Message object</a></li>
<li class="toctree-l1"><a class="reference internal" href="html.html">The MathJax.HTML object</a></li>
<li class="toctree-l1"><a class="reference internal" href="callback.html">The MathJax.CallBack class</a></li>
<li class="toctree-l1"><a class="reference internal" href="queue.html">The MathJax.CallBack.Queue class</a></li>
<li class="toctree-l1"><a class="reference internal" href="signal.html">The MathJax.CallBack.Signal class</a></li>
</ul>
</div>
<div class="toctree-wrapper compound">
<ul>
<li class="toctree-l1"><a class="reference internal" href="inputjax.html">The MathJax.InputJax class</a></li>
<li class="toctree-l1"><a class="reference internal" href="outputjax.html">The MathJax.OutputJax class</a></li>
<li class="toctree-l1"><a class="reference internal" href="elementjax.html">The MathJax.ElementJax class</a></li>
<li class="toctree-l1"><a class="reference internal" href="jax.html">The base Jax class</a></li>
</ul>
</div>
<div class="toctree-wrapper compound">
<ul>
<li class="toctree-l1"><a class="reference internal" href="object.html">The MathJax Object-Oriented Programming Model</a></li>
</ul>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h4>Previous topic</h4>
<p class="topless"><a href="../typeset.html"
title="previous chapter">Modifying Math on the Page</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="variable.html"
title="next chapter">The MathJax variable</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="variable.html" title="The MathJax variable"
>next</a> |</li>
<li class="right" >
<a href="../typeset.html" title="Modifying Math on the Page"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

299
docs/html/api/inputjax.html
View File

@ -1,299 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.InputJax Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.OutputJax Class" href="outputjax.html" />
<link rel="prev" title="The MathJax.Callback.Signal Class" href="signal.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="outputjax.html" title="The MathJax.OutputJax Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="signal.html" title="The MathJax.Callback.Signal Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-inputjax-class">
<span id="api-input-jax"></span><h1>The MathJax.InputJax Class<a class="headerlink" href="#the-mathjax-inputjax-class" title="Permalink to this headline"></a></h1>
<p>Input jax are the components of MathJax that translate
mathematics from its original format (like <a class="reference internal" href="../glossary.html#term-tex"><em class="xref std std-term">TeX</em></a> or
<a class="reference internal" href="../glossary.html#term-mathml"><em class="xref std std-term">MathML</em></a>) to the MathJax internal format (an <cite>element jax</cite>).</p>
<p>An input jax is stored as a pair of files in a subdirectory of the
<tt class="docutils literal"><span class="pre">jax/input</span></tt> directory, with the subdirectory name being the name of
the input jax. For example, the TeX input jax is stored in
<cite>jax/input/TeX</cite>. The first file, <tt class="docutils literal"><span class="pre">config.js</span></tt>, is loaded when
MathJax is being loaded and configured, and is indicated by listing
the input jax directory in the <cite>jax</cite> array of the MathJax
configuration. The <tt class="docutils literal"><span class="pre">config.js</span></tt> file creates a subclass of the
<cite>MathJax.InputJax</cite> object for the new input jax and registers that
with MathJax, along with the MIME-type that will be used to indicate
the mathematics that is to be processed by the input jax.</p>
<p>The main body of the input jax is stored in the second file,
<tt class="docutils literal"><span class="pre">jax.js</span></tt>, which is loaded when the input jax is first called on to
translate some mathematics. This file augments the original input jax
subclass with the additional methods needed to do the translation.
MathJax calls the input jax&#8217;s <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method when it needs
the input jax to translate the contents of a math <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag.</p>
<p>The <cite>MathJax.InputJax</cite> class is a subclass of the <a class="reference internal" href="jax.html#api-jax"><em>MathJax Jax</em></a> class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">id</tt></dt>
<dd><p>The name of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">version</tt></dt>
<dd><p>The version number of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">directory</tt></dt>
<dd><p>The directory where the jax files are stored (e.g., <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax/input/TeX&quot;</span></tt>).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">elementJax</tt></dt>
<dd><p>The name of the ElementJax class that this input jax will produce
(typically <tt class="docutils literal"><span class="pre">mml</span></tt>, as that is the only ElementJax at the moment).</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt>
<tt class="descname">Process</tt><big>(</big><em>script</em>, <em>state</em><big>)</big></dt>
<dd><p>This is the method that the <tt class="docutils literal"><span class="pre">MathJax.Hub</span></tt> calls when it needs
the input jax to process the given math <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt>. Its default
action is to do the following:</p>
<ol class="arabic simple">
<li>Start loading any element jax specified in the <tt class="docutils literal"><span class="pre">elementJax</span></tt> array;</li>
<li>Start loading the jax&#8217;s <tt class="docutils literal"><span class="pre">jax.js</span></tt> file;</li>
<li>Start loading the required output jax (so it is ready when needed); and</li>
<li>Redefine itself to simply return the callback for the load operation
(so that further calls to it will cause the processing to wait for the
callback).</li>
</ol>
<p>Once the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file has loaded, this method is replaced by
the jax&#8217;s <tt class="docutils literal"><span class="pre">Translate()</span></tt> method (see below), so that
subsequent calls to <tt class="docutils literal"><span class="pre">Process()</span></tt> will perform the appropriate
translation.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>script</strong> &#8212; reference to the DOM <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> object for</dt>
<dd><p class="first last">the mathematics to be translated</p>
</dd>
</dl>
</li>
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics
(internal use)</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">an <cite>ElementJax</cite> object, or <tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Translate</tt><big>(</big><em>script</em>, <em>state</em><big>)</big></dt>
<dd><p>This is the main routine called by MathJax when a <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> of the
appropriate type is found. The default <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method
throws an error indicating that <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> hasn&#8217;t been
defined, so when the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file loads, it should override the
default <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> with its own version that does the actual
translation.</p>
<p>The translation process should include the creation of an
<a class="reference internal" href="elementjax.html#api-element-jax"><em>Element Jax</em></a> that stores the data needed
for this element.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><p class="first"><strong>script</strong> &#8212; the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> element to be translated</p>
</li>
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics
(internal use)</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>element jax</cite> resulting from the translation</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Register</tt><big>(</big><em>mimetype</em><big>)</big></dt>
<dd><p>This registers the MIME-type associated with this input jax so
that MathJax knows to call this input jax when it sees a
<tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> of that type. An input jax can register more than
one type, but it will be responsible for distinguishing elements
of the various types from one another.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>mimetype</strong> &#8212; the MIME-type of the input this jax processes</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">needsUpdate</tt><big>(</big><em>jax</em><big>)</big></dt>
<dd><p>This implements the element jax&#8217;s <tt class="docutils literal"><span class="pre">needsUpdate()</span></tt> method, and
returns <tt class="docutils literal"><span class="pre">true</span></tt> if the <tt class="docutils literal"><span class="pre">jax</span></tt> needs to be rerendered (i.e., the
text has changed), and <tt class="docutils literal"><span class="pre">false</span></tt> otherwise.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Perameters :</th><td class="field-body"><ul class="first simple">
<li><strong>jax</strong> &#8212; the element jax to be checked</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">true</span></tt> if the jax&#8217;s text has changed, <tt class="docutils literal"><span class="pre">false</span></tt> otherwise</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.InputJax Class</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="signal.html"
title="previous chapter">The MathJax.Callback.Signal Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="outputjax.html"
title="next chapter">The MathJax.OutputJax Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="outputjax.html" title="The MathJax.OutputJax Class"
>next</a> |</li>
<li class="right" >
<a href="signal.html" title="The MathJax.Callback.Signal Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

303
docs/html/api/jax.html
View File

@ -1,303 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The Base Jax Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax Object-Oriented Programming Model" href="object.html" />
<link rel="prev" title="The MathJax.ElementJax Class" href="elementjax.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="object.html" title="The MathJax Object-Oriented Programming Model"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="elementjax.html" title="The MathJax.ElementJax Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-base-jax-class">
<span id="api-jax"></span><h1>The Base Jax Class<a class="headerlink" href="#the-base-jax-class" title="Permalink to this headline"></a></h1>
<p>The <cite>MathJax.InputJax</cite>, <cite>MathJax.OutputJax</cite> and <cite>MathJax.ElementJax</cite>
classes are all subclasses of the base <cite>Jax</cite> class in MathJax. This
is a private class that implements the methods common to all three
other jax classes.</p>
<p>Unlike most MathJax.Object classes, calling the class object creates a
<em>subclass</em> of the class, rather than an instance of the class. E.g.,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">InputJax</span><span class="p">.</span><span class="nx">MyInputJax</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">InputJax</span><span class="p">({</span>
<span class="nx">id</span><span class="o">:</span> <span class="s2">&quot;MyInputJax&quot;</span><span class="p">,</span>
<span class="nx">version</span><span class="o">:</span> <span class="s2">&quot;1.0&quot;</span><span class="p">,</span>
<span class="p">...</span>
<span class="p">});</span>
</pre></div>
</div>
<p>creates <tt class="docutils literal"><span class="pre">MathJax.InputJax.MyInputJax</span></tt> as a subclass of <tt class="docutils literal"><span class="pre">MathJax.InputJax</span></tt>.</p>
<div class="section" id="class-properties">
<h2>Class Properties<a class="headerlink" href="#class-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">directory</tt></dt>
<dd><p>The name of the jax directory (usually <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax&quot;</span></tt>).
Overridden in the subclass to be the specific directory for the
class, e.g. <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax/input&quot;</span></tt>.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">extensionDir</tt></dt>
<dd><p>The name of the extensions directory (usually <tt class="docutils literal"><span class="pre">&quot;[MathJax]/extensions&quot;</span></tt>).</p>
</dd></dl>
</div>
<div class="section" id="instance-properties">
<h2>Instance Properties<a class="headerlink" href="#instance-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">id</tt></dt>
<dd><p>The name of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">version</tt></dt>
<dd><p>The version number of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">directory</tt></dt>
<dd><p>The directory for the jax (e.g., <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax/input/TeX&quot;</span></tt>).</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">require: null</tt></dt>
<dd><p>An array of files to load before the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file calls the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.loadComplete()</span></tt> method.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">config: {}</tt></dt>
<dd><p>An object that contains the default configuration options for the
jax. These can be modified by the author by including a
configuration subsection for the specific jax in question.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">JAXFILE: &quot;jax.js&quot;</tt></dt>
<dd><p>The name of the file that contains the main code for the jax.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Translate">
<tt class="descname">Translate</tt><big>(</big><em>script</em><big>)</big><a class="headerlink" href="#Translate" title="Permalink to this definition"></a></dt>
<dd><p>This is a stub for a routine that should be defined by the jax&#8217;s
<tt class="docutils literal"><span class="pre">jax.js</span></tt> file when it is loaded. It should perform the translation
action for the specific jax. For an input jax, it should return the
<cite>ElementJax</cite> object that it created. The <a class="reference internal" href="#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method is
never called directly by MathJax; during the <tt class="docutils literal"><span class="pre">loadComplete()</span></tt>
call, this function is copied to the <a class="reference internal" href="hub.html#Process" title="Process"><tt class="xref py py-meth docutils literal"><span class="pre">Process()</span></tt></a> method, and is
called via that name. The default <a class="reference internal" href="#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method throws an
error indicating that the <a class="reference internal" href="#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method was not
redefined. That way, if the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file fails to load for some
reason, you will receive an error trying to process mathematics with
this jax.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>script</strong> &#8212; reference to the DOM <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> object for</dt>
<dd><p class="first last">the mathematics to be translated</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">an <cite>ElementJax</cite> object, or <tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Register">
<tt class="descname">Register</tt><big>(</big><em>mimetype</em><big>)</big><a class="headerlink" href="#Register" title="Permalink to this definition"></a></dt>
<dd><p>This method is overridden in the <cite>InputJax</cite>, <cite>OutputJax</cite> and
<cite>ElementJax</cite> subclasses to handle the registration of those
classes of jax.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>mimetype</strong> &#8212; the MIME-type to be associated with the jax</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Config</tt><big>(</big><big>)</big></dt>
<dd><p>Inserts the configuration block for this jax from the author&#8217;s
configuration specification into the jax&#8217;s <tt class="docutils literal"><span class="pre">config</span></tt> property.
If the configuration includes an <tt class="docutils literal"><span class="pre">Augment</span></tt> object, that is used
to augment the jax (that is, the configuration can override the
methods of the object, as well as the data). This is called
automatically during the loading of the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file.</p>
</dd></dl>
<dl class="method">
<dt id="Startup">
<tt class="descname">Startup</tt><big>(</big><big>)</big><a class="headerlink" href="#Startup" title="Permalink to this definition"></a></dt>
<dd><p>This is a method that can be overridden in the subclasses to
perform initialization at startup time (after the configuration
has occurred).</p>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">loadComplete</tt><big>(</big><em>file</em><big>)</big></dt>
<dd><p>This is called by the <tt class="docutils literal"><span class="pre">config.js</span></tt> and <tt class="docutils literal"><span class="pre">jax.js</span></tt> files when they
are completely loaded and are ready to signal that fact to
MathJax. For <tt class="docutils literal"><span class="pre">config.js</span></tt>, this simply calls the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.loadComplete()</span></tt> method for the <tt class="docutils literal"><span class="pre">config.js</span></tt>
file. For <tt class="docutils literal"><span class="pre">jax.js</span></tt>, the actions performed here are the
following:</p>
<blockquote>
<div><ol class="arabic simple">
<li>Post the &#8220;[name] Jax Config&#8221; message to the startup signal.</li>
<li>Perform the jax&#8217;s <a class="reference internal" href="hub.html#Config" title="Config"><tt class="xref py py-meth docutils literal"><span class="pre">Config()</span></tt></a> method.</li>
<li>Post the &#8220;[name] Jax Require&#8221; message to the startup signal.</li>
<li>Load the files from the jax&#8217;s <tt class="docutils literal"><span class="pre">require</span></tt> and
<tt class="docutils literal"><span class="pre">config.extensions</span></tt> arrays.</li>
<li>Post the &#8220;[name] Jax Startup&#8221; message to the startup signal.</li>
<li>Perform the jax&#8217;s <a class="reference internal" href="#Startup" title="Startup"><tt class="xref py py-meth docutils literal"><span class="pre">Startup()</span></tt></a> method.</li>
<li>Post the &#8220;[name] Jax Ready&#8221; message to the startup signal.</li>
<li>Copy the <tt class="docutils literal"><span class="pre">preTranslate</span></tt>, <tt class="docutils literal"><span class="pre">Translate</span></tt>, and
<tt class="docutils literal"><span class="pre">postTranslate</span></tt> functions to <tt class="docutils literal"><span class="pre">preProcess</span></tt>, <tt class="docutils literal"><span class="pre">Process</span></tt>,
and <tt class="docutils literal"><span class="pre">postProcess</span></tt>.</li>
<li>Perform the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.loadComplete()</span></tt> call for the
<tt class="docutils literal"><span class="pre">jax.js</span></tt> file.</li>
</ol>
</div></blockquote>
<p>Note that the configuration process (the <a class="reference internal" href="hub.html#Config" title="Config"><tt class="xref py py-meth docutils literal"><span class="pre">Config()</span></tt></a> call) can
modify the <tt class="docutils literal"><span class="pre">require</span></tt> or <tt class="docutils literal"><span class="pre">config.extensions</span></tt> arrays to add more
files that need to be loaded, and that the <a class="reference internal" href="#Startup" title="Startup"><tt class="xref py py-meth docutils literal"><span class="pre">Startup()</span></tt></a> method
isn&#8217;t called until those files are completely loaded.</p>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The Base Jax Class</a><ul>
<li><a class="reference internal" href="#class-properties">Class Properties</a></li>
<li><a class="reference internal" href="#instance-properties">Instance Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="elementjax.html"
title="previous chapter">The MathJax.ElementJax Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="object.html"
title="next chapter">The MathJax Object-Oriented Programming Model</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="object.html" title="The MathJax Object-Oriented Programming Model"
>next</a> |</li>
<li class="right" >
<a href="elementjax.html" title="The MathJax.ElementJax Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

285
docs/html/api/message.html
View File

@ -1,285 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Message Object &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.HTML Object" href="html.html" />
<link rel="prev" title="The MathJax.Ajax Object" href="ajax.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="html.html" title="The MathJax.HTML Object"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="ajax.html" title="The MathJax.Ajax Object"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-message-object">
<span id="api-message"></span><h1>The MathJax.Message Object<a class="headerlink" href="#the-mathjax-message-object" title="Permalink to this headline"></a></h1>
<p>The <tt class="docutils literal"><span class="pre">MathJax.Message</span></tt> object contains the methods used to manage the
small message area that appears at the lower-left corner of the
window. MathJax uses this area to inform the user of time-consuming
actions, like loading files and fonts, or how far along in the
typesetting process it is.</p>
<p>The page author can customize the look of the message window by
setting styles for the <tt class="docutils literal"><span class="pre">#MathJax_Message</span></tt> selector (which can be
set via</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">styles</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;#MathJax_Message&quot;</span><span class="o">:</span> <span class="p">{</span>
<span class="p">...</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>Because of a bug in Internet Explorer, in order to change the side of
the screen where the message occurs, you must also set the side
for <tt class="docutils literal"><span class="pre">#MathJax_MSIE_Frame</span></tt>, as in</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">styles</span><span class="o">:</span> <span class="p">{</span>
<span class="s2">&quot;#MathJax_Message&quot;</span><span class="o">:</span> <span class="p">{</span><span class="nx">left</span><span class="o">:</span> <span class="s2">&quot;&quot;</span><span class="p">,</span> <span class="nx">right</span><span class="o">:</span> <span class="mi">0</span><span class="p">},</span>
<span class="s2">&quot;#MathJax_MSIE_Frame&quot;</span><span class="o">:</span> <span class="p">{</span><span class="nx">left</span><span class="o">:</span> <span class="s2">&quot;&quot;</span><span class="p">,</span> <span class="nx">right</span><span class="o">:</span> <span class="mi">0</span><span class="p">}</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>It is possible that a message is already being displayed when another
message needs to be posted. For this reason, when a message is
displayed on screen, it gets an id number that is used when you want
to remove or change that message. That way, when a message is
removed, the previous message (if any) can be redisplayed if it hasn&#8217;t
been removed. This allows for intermittent messages (like file
loading messages) to obscure longer-term messages (like &#8220;Processing
Math&#8221; messages) temporarily.</p>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Set">
<tt class="descname">Set</tt><big>(</big><em>message</em><span class="optional">[</span>, <em>n</em><span class="optional">[</span>, <em>delay</em><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#Set" title="Permalink to this definition"></a></dt>
<dd><p>This sets the message being displayed to the given <cite>message</cite>
string. If <cite>n</cite> is not <tt class="docutils literal"><span class="pre">null</span></tt>, it represents a message id
number and the text is set for that message id, otherwise a new id
number is created for this message. If <cite>delay</cite> is provided, it is
the time (in milliseconds) to display the message before it is
cleared. If <cite>delay</cite> is not provided, the message will not be
removed automatically; you must call the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Messsage.Clear()</span></tt> method by hand to remove it.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>message</strong> &#8212; the text to display in the message area</li>
<li><strong>n</strong> &#8212; the message id number</li>
<li><strong>delay</strong> &#8212; amout of time to display the message</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the message id number for this message.</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Clear">
<tt class="descname">Clear</tt><big>(</big><em>n</em><span class="optional">[</span>, <em>delay</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Clear" title="Permalink to this definition"></a></dt>
<dd><p>This causes the message with id <cite>n</cite> to be removed after the given
<cite>delay</cite>, in milliseconds. The default delay is 600 milliseconds.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>n</strong> &#8212; the message id number</li>
<li><strong>delay</strong> &#8212; the delay before removing the message</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Remove">
<tt class="descname">Remove</tt><big>(</big><big>)</big><a class="headerlink" href="#Remove" title="Permalink to this definition"></a></dt>
<dd><p>This removes the message frame from the window (it will reappear when
future messages are set, however).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><tt class="docutils literal"><span class="pre">null</span></tt></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="File">
<tt class="descname">File</tt><big>(</big><em>file</em><big>)</big><a class="headerlink" href="#File" title="Permalink to this definition"></a></dt>
<dd><p>This sets the message area to a &#8220;Loading <em>file</em>&#8221; message, where <em>file</em>
is the name of the file (with <tt class="docutils literal"><span class="pre">[MathJax]</span></tt> representing the root
directory).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>file</strong> &#8212; the name of the file being loaded</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the message id number for the message created</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="filterText">
<tt class="descname">filterText</tt><big>(</big><em>text</em>, <em>n</em><big>)</big><a class="headerlink" href="#filterText" title="Permalink to this definition"></a></dt>
<dd><p>This method is called on each message before it is displayed. It can
be used to modify (e.g., shorten) the various messages before they are
displayed. The default action is to check if the <tt class="docutils literal"><span class="pre">messageStyle</span></tt>
configuration parameter is <tt class="docutils literal"><span class="pre">simple</span></tt>, and if so, convert loading and
processing messages to a simpler form. This method can be overridden
to perform other sanitization of the message strings.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>text</strong> &#8212; the text of the message to be posted</li>
<li><strong>n</strong> &#8212; the id number of the message to be posted</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the modified message text</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Log">
<tt class="descname">Log</tt><big>(</big><big>)</big><a class="headerlink" href="#Log" title="Permalink to this definition"></a></dt>
<dd><p>Returns a string of all the messages issued so far, separated by
newlines. This is used in debugging MathJax operations.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Returns :</th><td class="field-body">string of all messages so far</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Message Object</a><ul>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="ajax.html"
title="previous chapter">The MathJax.Ajax Object</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="html.html"
title="next chapter">The MathJax.HTML Object</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="html.html" title="The MathJax.HTML Object"
>next</a> |</li>
<li class="right" >
<a href="ajax.html" title="The MathJax.Ajax Object"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

354
docs/html/api/object.html
View File

@ -1,354 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax Object-Oriented Programming Model &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="Describing HTML snippets" href="../HTML-snippets.html" />
<link rel="prev" title="The Base Jax Class" href="jax.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../HTML-snippets.html" title="Describing HTML snippets"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="jax.html" title="The Base Jax Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-object-oriented-programming-model">
<span id="api-object"></span><h1>The MathJax Object-Oriented Programming Model<a class="headerlink" href="#the-mathjax-object-oriented-programming-model" title="Permalink to this headline"></a></h1>
<p>MathJax uses an object-oriented programming model for its main
components, such as the <cite>Input jax</cite>, <cite>Output jax</cite>, and <cite>Element jax</cite>.
The model is intended to be light-weight and is based on JavaScript&#8217;s
prototype inheritance mechanism. Object classes are created by making
subclasses of <cite>MathJax.Object</cite> or one of its subclasses, and are
instantiated by calling the object class as you would a function.</p>
<p>For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Foo</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">Init</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">setX</span><span class="p">(</span><span class="nx">x</span><span class="p">)},</span>
<span class="nx">getX</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span><span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">x</span><span class="p">},</span>
<span class="nx">setX</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span><span class="p">}</span>
<span class="p">});</span>
<span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Foo</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">getX</span><span class="p">();</span> <span class="c1">// returns &quot;bar&quot;</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">setX</span><span class="p">(</span><span class="s2">&quot;foobar&quot;</span><span class="p">);</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">getX</span><span class="p">();</span> <span class="c1">// returns &quot;foobar&quot;</span>
</pre></div>
</div>
<p>Object classes can have static properties and methods, which are
accessed via the object class variable. E.g.,
<tt class="docutils literal"><span class="pre">MathJax.Object.Foo.SUPER</span></tt> or <tt class="docutils literal"><span class="pre">MathJax.Object.Foo.Augment()</span></tt> for
the object in the example above. Static values are not inherited by
subclasses.</p>
<div class="section" id="static-properties">
<h2>Static Properties<a class="headerlink" href="#static-properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">SUPER</tt></dt>
<dd><p>Pointer to the super class for this subclass. (It is a reference to
<cite>MathJax.Object</cite> in the example above.)</p>
</dd></dl>
</div>
<div class="section" id="static-methods">
<h2>Static Methods<a class="headerlink" href="#static-methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Subclass">
<tt class="descname">Subclass</tt><big>(</big><em>def</em><span class="optional">[</span>, <em>static</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Subclass" title="Permalink to this definition"></a></dt>
<dd><p>Creates a subclass of the given class using the contents of the
<cite>def</cite> object to define new methods and properties of the object
class, and the contents of the optional <cite>static</cite> object to define
new static methods and properties.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> &#8212; object that defines the properties and methods</li>
<li><strong>static</strong> &#8212; object that defines static properties and methods</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the new object class</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Augment">
<tt class="descname">Augment</tt><big>(</big><em>def</em><span class="optional">[</span>, <em>static</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Augment" title="Permalink to this definition"></a></dt>
<dd><p>Adds new properties and methods to the class prototype. All
instances of the object already in existence will receive the new
properties and methods automatically.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> &#8212; object that defines the properties and methods</li>
<li><strong>static</strong> &#8212; object that defines static properties and methods</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the object class itself</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">constructor</tt></dt>
<dd><p>Pointer to the constructor function for this class. E.g.,
<tt class="docutils literal"><span class="pre">foo.constructor</span></tt> would be a reference to <tt class="docutils literal"><span class="pre">MathJax.Object.Foo</span></tt>
in the example above.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Init">
<tt class="descname">Init</tt><big>(</big><span class="optional">[</span><em>data</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Init" title="Permalink to this definition"></a></dt>
<dd><p>An optional function that is called when an instance of the class
is created. When called, the <cite>this</cite> variable is set to the newly
instantiated object, and the <cite>data</cite> is whatever was passed to the
object constructor. For instance, in the example above, the
variable <tt class="docutils literal"><span class="pre">foo</span></tt> is created by calling
<tt class="docutils literal"><span class="pre">MathJax.Object.Foo(&quot;bar&quot;)</span></tt>, which calls the
<tt class="docutils literal"><span class="pre">MathJax.Object.Foo</span></tt> object&#8217;s <a class="reference internal" href="#Init" title="Init"><tt class="xref py py-meth docutils literal"><span class="pre">Init()</span></tt></a> method with <cite>data</cite>
equal to <tt class="docutils literal"><span class="pre">&quot;bar&quot;</span></tt>. If desired, the <a class="reference internal" href="#Init" title="Init"><tt class="xref py py-meth docutils literal"><span class="pre">Init()</span></tt></a> method can
create a <em>different</em> object, and return that, in which case this
becomes the return value for the object constructor.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>data</strong> &#8212; the data from the constructor call</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt> or the object to be returned by the constructor</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="isa">
<tt class="descname">isa</tt><big>(</big><em>class</em><big>)</big><a class="headerlink" href="#isa" title="Permalink to this definition"></a></dt>
<dd><p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if the object is an instance of the given class,
or of a subclass of the given class, and <tt class="docutils literal"><span class="pre">false</span></tt> otherwise. So
using the <tt class="docutils literal"><span class="pre">foo</span></tt> value defined above,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">foo</span><span class="p">.</span><span class="nx">isa</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">);</span> <span class="c1">// returns true</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">isa</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Foo</span><span class="p">);</span> <span class="c1">// returns true</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">isa</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">InputJax</span><span class="p">);</span> <span class="c1">// returns false</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="can">
<tt class="descname">can</tt><big>(</big><em>method</em><big>)</big><a class="headerlink" href="#can" title="Permalink to this definition"></a></dt>
<dd><p>Checks if the object has the given <cite>method</cite> and returns <tt class="docutils literal"><span class="pre">true</span></tt>
if so, otherwise returns <tt class="docutils literal"><span class="pre">false</span></tt>. This allows you to test if an
object has a particular function available before trying to call
it (i.e., if an object implements a particular feature). For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">foo</span><span class="p">.</span><span class="nx">can</span><span class="p">(</span><span class="s2">&quot;getX&quot;</span><span class="p">);</span> <span class="c1">// returns true</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">can</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span> <span class="c1">// returns false</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="has">
<tt class="descname">has</tt><big>(</big><em>property</em><big>)</big><a class="headerlink" href="#has" title="Permalink to this definition"></a></dt>
<dd><p>Checks if the object has the given <cite>property</cite> and returns <tt class="docutils literal"><span class="pre">true</span></tt>
if so, otherwise returns <tt class="docutils literal"><span class="pre">false</span></tt>. This allows you to test if an
object has a particular property available before trying to use
it. For example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">foo</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="s2">&quot;getX&quot;</span><span class="p">);</span> <span class="c1">// returns true</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="s2">&quot;x&quot;</span><span class="p">);</span> <span class="c1">// returns true</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span> <span class="c1">// returns false</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="accessing-the-super-class">
<h2>Accessing the Super Class<a class="headerlink" href="#accessing-the-super-class" title="Permalink to this headline"></a></h2>
<p>If a subclass overrides a method of its parent class, it may want to
call the original function as part of its replacement method. The
semantics for this are a bit awkward, but work efficiently. Within a
method, the value <tt class="docutils literal"><span class="pre">arguments.callee.SUPER</span></tt> refers to the super
class, so you can access any method of the superclass using that. In
order to have <cite>this</cite> refer to the current object when you call the
super class, however, you need to use <tt class="docutils literal"><span class="pre">call()</span></tt> or
<tt class="docutils literal"><span class="pre">apply()</span></tt> to access the given method.</p>
<p>For example, <tt class="docutils literal"><span class="pre">arguments.callee.SUPER.method.call(this,data)</span></tt> would
call the superclass&#8217; <cite>method</cite> and pass it <cite>data</cite> as its argument,
properly passing the current object as <cite>this</cite>. Alternatively, you can
use <tt class="docutils literal"><span class="pre">this.SUPER(arguments)</span></tt> in place of <tt class="docutils literal"><span class="pre">arguments.callee.SUPER</span></tt>.
It is also possible to refer to the super class explicitly rather than
through <tt class="docutils literal"><span class="pre">arguments.callee.SUPER</span></tt>, as in the following example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class1</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">Init</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span><span class="p">},</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class1: x and y = &quot;</span> <span class="o">+</span> <span class="k">this</span><span class="p">.</span><span class="nx">x</span> <span class="o">+</span> <span class="s2">&quot; and &quot;</span> <span class="o">+</span> <span class="nx">y</span><span class="p">}</span>
<span class="p">});</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class1</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class2: &quot;</span><span class="o">+</span><span class="nx">arguments</span><span class="p">.</span><span class="nx">callee</span><span class="p">.</span><span class="nx">SUPER</span><span class="p">.</span><span class="nx">XandY</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="nx">y</span><span class="p">)}</span>
<span class="p">});</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class3</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class3: &quot;</span><span class="o">+</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">XandY</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="nx">y</span><span class="p">)}</span>
<span class="p">});</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class4</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class1</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class4: &quot;</span><span class="o">+</span><span class="k">this</span><span class="p">.</span><span class="nx">SUPER</span><span class="p">(</span><span class="nx">arguments</span><span class="p">).</span><span class="nx">XandY</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="nx">y</span><span class="p">)}</span>
<span class="p">});</span>
<span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span><span class="p">(</span><span class="s2">&quot;foo&quot;</span><span class="p">);</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">XandY</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span> <span class="c1">// returns &quot;Class2: Class1: x and y = foo and bar&quot;</span>
<span class="kd">var</span> <span class="nx">bar</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class3</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span>
<span class="nx">bar</span><span class="p">.</span><span class="nx">XandY</span><span class="p">(</span><span class="s2">&quot;foo&quot;</span><span class="p">);</span> <span class="c1">// returns &quot;Class3: Class2: Class1: x and y = bar and foo&quot;</span>
<span class="kd">var</span> <span class="nx">moo</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class4</span><span class="p">(</span><span class="s2">&quot;moo&quot;</span><span class="p">);</span>
<span class="nx">moo</span><span class="p">.</span><span class="nx">XandY</span><span class="p">(</span><span class="s2">&quot;cow&quot;</span><span class="p">);</span> <span class="c1">// returns &quot;Class4: Class1: x and y = moo and cow&quot;</span>
</pre></div>
</div>
<p>Since both of these mechanisms are rather awkward, MathJax provides an
alternative syntax that is easier on the programmer, but at the cost
of some inefficiency in creating the subclass and in calling methods
that access the super class.</p>
<p>Since most calls to the super class are to the overridden method, not
to some other method, the method name and the <tt class="docutils literal"><span class="pre">call()</span></tt> are
essentially redundant. You can get a more convenient syntax by
wrapping the <cite>def</cite> for the <a class="reference internal" href="#Subclass" title="Subclass"><tt class="xref py py-meth docutils literal"><span class="pre">Subclass()</span></tt></a> call in a call to
<tt class="docutils literal"><span class="pre">MathJax.Object.SimpleSUPER()</span></tt>, as in the following example:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class1</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">({</span>
<span class="nx">Init</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span><span class="p">},</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class1: x and y = &quot;</span> <span class="o">+</span> <span class="k">this</span><span class="p">.</span><span class="nx">x</span> <span class="o">+</span> <span class="s2">&quot; and &quot;</span> <span class="o">+</span> <span class="nx">y</span><span class="p">}</span>
<span class="p">});</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class1</span><span class="p">.</span><span class="nx">Subclass</span><span class="p">(</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nb">Object</span><span class="p">.</span><span class="nx">SimpleSUPER</span><span class="p">({</span>
<span class="nx">XandY</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span><span class="k">return</span> <span class="s2">&quot;Class2: &quot;</span><span class="o">+</span><span class="k">this</span><span class="p">.</span><span class="nx">SUPER</span><span class="p">(</span><span class="nx">y</span><span class="p">)},</span>
<span class="nx">AnotherMethod</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span><span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">x</span><span class="p">}</span> <span class="c1">// it&#39;s OK if a method doesn&#39;t use SUPER</span>
<span class="p">})</span>
<span class="p">);</span>
<span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Class2</span><span class="p">(</span><span class="s2">&quot;foo&quot;</span><span class="p">);</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">XandY</span><span class="p">(</span><span class="s2">&quot;bar&quot;</span><span class="p">);</span> <span class="c1">// returns &quot;Class2: Class1: x and y = foo and bar&quot;</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax Object-Oriented Programming Model</a><ul>
<li><a class="reference internal" href="#static-properties">Static Properties</a></li>
<li><a class="reference internal" href="#static-methods">Static Methods</a></li>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
<li><a class="reference internal" href="#accessing-the-super-class">Accessing the Super Class</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="jax.html"
title="previous chapter">The Base Jax Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="../HTML-snippets.html"
title="next chapter">Describing HTML snippets</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../HTML-snippets.html" title="Describing HTML snippets"
>next</a> |</li>
<li class="right" >
<a href="jax.html" title="The Base Jax Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

448
docs/html/api/outputjax.html
View File

@ -1,448 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.OutputJax Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.ElementJax Class" href="elementjax.html" />
<link rel="prev" title="The MathJax.InputJax Class" href="inputjax.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="elementjax.html" title="The MathJax.ElementJax Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="inputjax.html" title="The MathJax.InputJax Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-outputjax-class">
<span id="api-output-jax"></span><h1>The MathJax.OutputJax Class<a class="headerlink" href="#the-mathjax-outputjax-class" title="Permalink to this headline"></a></h1>
<p>Output jax are the components of MathJax that translate
mathematics from the MathJax internal format (an <cite>element jax</cite>)
to whatever output is required to represent the mathematics (e.g.,
MathML elements, or HTML-with-CSS that formats the mathematics on screen).</p>
<p>An output jax is stored as a pair of files in a subdirectory of the
the <tt class="docutils literal"><span class="pre">jax/output</span></tt> directory, with the subdirectory name being the
name of the output jax. For example, the NativeMML output jax is
stored in <cite>jax/output/NativeMML</cite>. The first file, <tt class="docutils literal"><span class="pre">config.js</span></tt>, is
loaded when MathJax is being loaded and configured, and is indicated
by listing the input jax directory in the <cite>jax</cite> array of the MathJax
configuration. The <tt class="docutils literal"><span class="pre">config.js</span></tt> file creates a subclass of the
<cite>MathJax.OutputJax</cite> object for the new output jax and registers it
with MathJax, along with the MIME-type of the element jax that it can
process.</p>
<p>The main body of the output jax is stored in the second file, <tt class="docutils literal"><span class="pre">jax.js</span></tt>,
which is loaded when the output jax is first called on to translate
some mathematics. This file augments the original output jax
subclass with the additional methods needed to produce the output.
MathJax calls the input jax&#8217;s <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> method when it needs
the output jax to translate an element jax to produce output.</p>
<p>The <cite>MathJax.OutputJax</cite> class is a subclass of the <a class="reference internal" href="jax.html#api-jax"><em>MathJax Jax</em></a> class, and inherits the properties and methods of that
class. Those listed below are the additional or overridden ones from
that class.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">id</tt></dt>
<dd><p>The name of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">version</tt></dt>
<dd><p>The version number of the jax.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">directory</tt></dt>
<dd><p>The directory where the jax files are stored (e.g., <tt class="docutils literal"><span class="pre">&quot;[MathJax]/jax/output/HTML-CSS&quot;</span></tt>);</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">fontDir</tt></dt>
<dd><p>The directory where the fonts are stored (e.g., <tt class="docutils literal"><span class="pre">&quot;[MathJax]/fonts&quot;</span></tt>)</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">imageDir</tt></dt>
<dd><p>The directory where MathJax images are found (e.g. <tt class="docutils literal"><span class="pre">&quot;[MathJax]/images&quot;</span></tt>)</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="preProcess">
<tt class="descname">preProcess</tt><big>(</big><em>state</em><big>)</big><a class="headerlink" href="#preProcess" title="Permalink to this definition"></a></dt>
<dd><p>This is called by <tt class="docutils literal"><span class="pre">MathJax.Hub</span></tt> to ask the output processor to
prepare to process math scripts. Its default action is to start
loading the jax&#8217;s <tt class="docutils literal"><span class="pre">jax.js</span></tt> file, and redefine itself to simply
return the callback for the load operation (so that further calls
to it will cause the processing to wait for the callback).</p>
<p>Once the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file has loaded, this method is replaced by
the jax&#8217;s <a class="reference internal" href="#preTranslate" title="preTranslate"><tt class="xref py py-meth docutils literal"><span class="pre">preTranslate()</span></tt></a> method, so that subsequent calls
to <a class="reference internal" href="#preProcess" title="preProcess"><tt class="xref py py-meth docutils literal"><span class="pre">preProcess()</span></tt></a> will perform the appropriate translation.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="preTranslate">
<tt class="descname">preTranslate</tt><big>(</big><em>state</em><big>)</big><a class="headerlink" href="#preTranslate" title="Permalink to this definition"></a></dt>
<dd><p>This routine replaces <a class="reference internal" href="#preProcess" title="preProcess"><tt class="xref py py-meth docutils literal"><span class="pre">preProcess()</span></tt></a> above when the jax&#8217;s
<tt class="docutils literal"><span class="pre">jax.js</span></tt> file is loaded. It is called by <tt class="docutils literal"><span class="pre">MathJax.Hub</span></tt> to ask
the output processor to prepare to process math scripts. (For
example, the HTML-CSS output jax uses this to determine em-sizes
for all the mathematics at once, to minimize page reflows that
slow down Internet Explorer.)</p>
<p>The routine can use <tt class="docutils literal"><span class="pre">state.jax[this.id]</span></tt> to obtain the array of
element jax that are to be processed. The output jax can use the
<tt class="docutils literal"><span class="pre">state</span></tt> variable to maintain its own state information, but
any properties that it adds to the variable should have a prefix
that is the output jax&#8217;s ID. For example, the HTML-CSS output jax
might use <tt class="docutils literal"><span class="pre">state.HTMLCSSlast</span></tt> to keep track of the last equation
it processed, or could add <tt class="docutils literal"><span class="pre">state.HTMLCSS</span> <span class="pre">=</span> <span class="pre">{...}</span></tt> to create an
object of its own within the state variable.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Translate</tt><big>(</big><em>script</em>, <em>state</em><big>)</big></dt>
<dd><p>This is the main routine called by MathJax when an element jax is
to be converted to output. The default <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a>
method throws an error indicating that <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> hasn&#8217;t been
defined, so when the <tt class="docutils literal"><span class="pre">jax.js</span></tt> file loads, it should override the
default <a class="reference internal" href="jax.html#Translate" title="Translate"><tt class="xref py py-meth docutils literal"><span class="pre">Translate()</span></tt></a> with its own version that does the actual
translation.</p>
<p>You should use <tt class="docutils literal"><span class="pre">MathJax.Hub.getJaxFor(script)</span></tt> to obtain the
element jax for the given script. The translation process may
modify the element jax (e.g., if it has data that needs to be
stored with the jax), and may insert DOM elements into the
document near the jax&#8217;s <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> tag. The output jax can use
the <tt class="docutils literal"><span class="pre">state</span></tt> variable to maintain information about its
processing state, but see <a class="reference internal" href="#preTranslate" title="preTranslate"><tt class="xref py py-meth docutils literal"><span class="pre">preTranslate()</span></tt></a> above for naming
conventions for properties that are added.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><p class="first"><strong>script</strong> &#8212; the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt> element to be translated</p>
</li>
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>element jax</cite> resulting from the translation</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="postTranslate">
<tt class="descname">postTranslate</tt><big>(</big><em>state</em><big>)</big><a class="headerlink" href="#postTranslate" title="Permalink to this definition"></a></dt>
<dd><p>This routines is called by <tt class="docutils literal"><span class="pre">MathJax.Hub</span></tt> when the translation
of math elements is complete, and can be used by the output
processor to finalize any actions that it needs to complete.
(For example, making the mathematics visible, or forcing a reflow
of the page.)</p>
<p>The routine can use <tt class="docutils literal"><span class="pre">state.jax[this.id]</span></tt> to obtain the array of
element jax that were processed, or can use the <tt class="docutils literal"><span class="pre">state</span></tt> variable
to store its own state information (see <a class="reference internal" href="#preProcess" title="preProcess"><tt class="xref py py-meth docutils literal"><span class="pre">preProcess()</span></tt></a>
above for caveats about naming properties).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>state</strong> &#8212; a structure containing information about the</dt>
<dd><p class="first last">current proccessing state of the mathematics</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Register</tt><big>(</big><em>mimetype</em><big>)</big></dt>
<dd><p>This registers the MIME-type for the element jax associated with
this output jax so that MathJax knows to call this jax when it
wants to display an element jax of that type. Several output jax
may register for the same input jax, in which case the first one
to register will be the default one for that type.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>mimetype</strong> &#8212; the MIME-type of the input this jax processes</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Remove</tt><big>(</big><em>jax</em><big>)</big></dt>
<dd><p>Removes the output associated with the given element jax. The
routine can use <tt class="docutils literal"><span class="pre">jax.SourceElement()</span></tt> to locate the <tt class="docutils literal"><span class="pre">&lt;script&gt;</span></tt>
tag associated with the element jax.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>jax</strong> &#8212; the element jax whose display should be removed</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<p>If an output jax wants its output to handle the contextual menu item
and zooming, then it needs to tie into the event-handling code
(<cite>MathEvents</cite>) and the zoom-handling code (<cite>MathZoom</cite>). That requires
the following methods.</p>
<dl class="method">
<dt id="getJaxFromMath">
<tt class="descname">getJaxFromMath</tt><big>(</big><em>math</em><big>)</big><a class="headerlink" href="#getJaxFromMath" title="Permalink to this definition"></a></dt>
<dd><p>This is called by the event-handling code (<cite>MathEvents</cite>) to get
the element jax associated with the DOM element that caused an
event to occur. The output jax will have attached event handlers
to some DOM element that is part of its output, and the
<cite>MathEvents</cite> code uses this routine to map back to the jax
associated with that output.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first">
<li><dl class="first docutils">
<dt><strong>math</strong> &#8212; a DOM element that triggered a DOM event</dt>
<dd><p class="first last">(e.g., a mouse click)</p>
</dd>
</dl>
</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the <cite>ElementJax</cite> structure associated with the DOM element</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Zoom">
<tt class="descname">Zoom</tt><big>(</big><em>jax</em>, <em>span</em>, <em>math</em>, <em>Mw</em>, <em>Mh</em><big>)</big><a class="headerlink" href="#Zoom" title="Permalink to this definition"></a></dt>
<dd><p>This routine is called by the zoom-handling code (<cite>MathZoom</cite>)
when an expression has received its zoom trigger event (e.g., a
double-click). The <tt class="docutils literal"><span class="pre">jax</span></tt> is the math that needs to be zoomed,
<tt class="docutils literal"><span class="pre">span</span></tt> is a <tt class="docutils literal"><span class="pre">&lt;span&gt;</span></tt> element in which the zoomed version of
the math should be placed, <tt class="docutils literal"><span class="pre">math</span></tt> is the DOM element that
received the zoom trigger event, and <tt class="docutils literal"><span class="pre">Mw</span></tt> and <tt class="docutils literal"><span class="pre">Mh</span></tt> are the
maximum width and height allowed for the zoom box (the <tt class="docutils literal"><span class="pre">span</span></tt>).</p>
<p>The return value is an object with the following properties:</p>
<ul>
<li><dl class="first docutils">
<dt><tt class="docutils literal"><span class="pre">Y</span></tt> &#8212; the vertical offset from the top of the <tt class="docutils literal"><span class="pre">span</span></tt> to</dt>
<dd><p class="first last">the baseline of the mathematics</p>
</dd>
</dl>
</li>
<li><p class="first"><tt class="docutils literal"><span class="pre">mW</span></tt> &#8212; the width of the original mathematics element</p>
</li>
<li><p class="first"><tt class="docutils literal"><span class="pre">mH</span></tt> &#8212; the height of the original mathematics element</p>
</li>
<li><p class="first"><tt class="docutils literal"><span class="pre">zW</span></tt> &#8212; the width of the zoomed math</p>
</li>
<li><p class="first"><tt class="docutils literal"><span class="pre">zH</span></tt> &#8212; the height of the zoomed math</p>
</li>
</ul>
<p>All of these values are in pixels.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>jax</strong> &#8212; the jax to be zoomed</li>
<li><strong>span</strong> &#8212; the <tt class="docutils literal"><span class="pre">&lt;span&gt;</span></tt> in which to place the zoomed math</li>
<li><strong>math</strong> &#8212; the DOM element generating the zoom event</li>
<li><strong>Mw</strong> &#8212; the maximum width of the zoom box</li>
<li><strong>Mh</strong> &#8212; the maximum height of the zoom box</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">a structure as described above</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.OutputJax Class</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="inputjax.html"
title="previous chapter">The MathJax.InputJax Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="elementjax.html"
title="next chapter">The MathJax.ElementJax Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="elementjax.html" title="The MathJax.ElementJax Class"
>next</a> |</li>
<li class="right" >
<a href="inputjax.html" title="The MathJax.InputJax Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

244
docs/html/api/queue.html
View File

@ -1,244 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Callback.Queue Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Callback.Signal Class" href="signal.html" />
<link rel="prev" title="The MathJax.Callback Class" href="callback.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="signal.html" title="The MathJax.Callback.Signal Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="callback.html" title="The MathJax.Callback Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-callback-queue-class">
<span id="api-queue"></span><h1>The MathJax.Callback.Queue Class<a class="headerlink" href="#the-mathjax-callback-queue-class" title="Permalink to this headline"></a></h1>
<p>The <tt class="docutils literal"><span class="pre">MathJax.Callback.Queue</span></tt> object is one of the key mechanisms
used by MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A <cite>Queue</cite> object
is used to coordinate a sequence of actions so that they are performed
one after another, even when one action has to wait for an
asynchronous process to complete. This guarantees that operations are
performed in the right order even when the code must wait for some
other action to occur. See <a class="reference internal" href="../synchronize.html#synchronization"><em>Synchronizing with MathJax</em></a> for more details, and <a class="reference internal" href="../queues.html#using-queues"><em>Using Queues</em></a> in particular for examples of how to specify and use
MathJax <cite>Queue</cite> objects.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">pending</tt></dt>
<dd><p>This is non-zero when the queue is waiting for a command to
complete, i.e. a command being processed returns a <cite>Callback</cite>
object, indicating that the queue should wait for that action to
complete before processing additional commands.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">running</tt></dt>
<dd><p>This is non-zero when the queue is executing one of the commands in
the queue.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">queue</tt></dt>
<dd><p>An array containing the queued commands that are yet to be performed.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Push">
<tt class="descname">Push</tt><big>(</big><em>callback</em>, <em>...</em><big>)</big><a class="headerlink" href="#Push" title="Permalink to this definition"></a></dt>
<dd><p>Adds commands to the queue and runs them (if the queue is not
pending or running another command). If one of the callbacks is
an actual <cite>Callback</cite> object rather than a callback specification,
then the command queued is an internal command to wait for the
given callback to complete. That is, that callback is not itself
queued to be executed, but a wait for that callback is queued.
The <a class="reference internal" href="#Push" title="Push"><tt class="xref py py-meth docutils literal"><span class="pre">Push()</span></tt></a> method returns the last callback that was
added to the queue (so that it can be used for further
synchronization, say as an entry in some other queue).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the callback specifications to be added to the queue</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the last callback object added to the queue</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Process</tt><big>(</big><big>)</big></dt>
<dd><p>Process the commands in the queue, provided the queue is not
waiting for another command to complete. This method is used
internally; you should not need to call it yourself.</p>
</dd></dl>
<dl class="method">
<dt id="Suspend">
<tt class="descname">Suspend</tt><big>(</big><big>)</big><a class="headerlink" href="#Suspend" title="Permalink to this definition"></a></dt>
<dd><p>Increments the <cite>running</cite> property, indicating that any commands that
are added to the queue should not be executed immediately, but should
be queued for later execution (when its <a class="reference internal" href="#Resume" title="Resume"><tt class="xref py py-meth docutils literal"><span class="pre">Resume()</span></tt></a> is
called). This method is used internally; you should not need to
call it yourself.</p>
</dd></dl>
<dl class="method">
<dt id="Resume">
<tt class="descname">Resume</tt><big>(</big><big>)</big><a class="headerlink" href="#Resume" title="Permalink to this definition"></a></dt>
<dd><p>Decrements the <cite>running</cite> property, if it is positive. When it is
zero, commands can be processed, but that is not done
automatically &#8212; you would need to call <a class="reference internal" href="hub.html#Process" title="Process"><tt class="xref py py-meth docutils literal"><span class="pre">Process()</span></tt></a> to make
that happen. This method is used internally; you should not need
to call it yourself.</p>
</dd></dl>
<dl class="method">
<dt id="wait">
<tt class="descname">wait</tt><big>(</big><em>callback</em><big>)</big><a class="headerlink" href="#wait" title="Permalink to this definition"></a></dt>
<dd><p>Used internally when an entry in the queue is a <cite>Callback</cite> object
rather than a callback specification. A callback to this function
(passing it the original callback) is queued instead, and it
simply returns the callback it was passed. Since the queue will
wait for a callback if it is the return value of one of the
commands it executes, this effectively makes the queue wait for the
original callback at that point in the command queue.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the function to complete before returning to the queue</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the passed callback function</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="call">
<tt class="descname">call</tt><big>(</big><big>)</big><a class="headerlink" href="#call" title="Permalink to this definition"></a></dt>
<dd><p>An internal function used to restart processing of the queue after
it has been waiting for a command to complete.</p>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Callback.Queue Class</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="callback.html"
title="previous chapter">The MathJax.Callback Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="signal.html"
title="next chapter">The MathJax.Callback.Signal Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="signal.html" title="The MathJax.Callback.Signal Class"
>next</a> |</li>
<li class="right" >
<a href="callback.html" title="The MathJax.Callback Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

332
docs/html/api/signal.html
View File

@ -1,332 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax.Callback.Signal Class &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.InputJax Class" href="inputjax.html" />
<link rel="prev" title="The MathJax.Callback.Queue Class" href="queue.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="inputjax.html" title="The MathJax.InputJax Class"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="queue.html" title="The MathJax.Callback.Queue Class"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-callback-signal-class">
<span id="api-signal"></span><h1>The MathJax.Callback.Signal Class<a class="headerlink" href="#the-mathjax-callback-signal-class" title="Permalink to this headline"></a></h1>
<p>The <tt class="docutils literal"><span class="pre">MathJax.Callback.Signal</span></tt> object is one of the key mechanisms
used by MathJax to synchronize its actions with those that occur
asynchronously, like loading files and stylesheets. A <cite>Signal</cite> object
is used to publicize the fact that MathJax has performed certain
actions, giving other code running the web page the chance to react to
those actions. See <a class="reference internal" href="../synchronize.html#synchronization"><em>Synchronizing with MathJax</em></a> for more details, and <a class="reference internal" href="../signals.html#using-signals"><em>Using Signals</em></a> in particular for examples of how to specify and use
MathJax <cite>Signal</cite> objects.</p>
<p>The <cite>Callback Signal</cite> object is a subclass of the <a class="reference internal" href="queue.html#api-queue"><em>Callback Queue</em></a> object.</p>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">name</tt></dt>
<dd><p>The name of the signal. Each signal is named so that
various components can access it. The first one to request a
particular signal causes it to be created, and other requests for
the signal return references to the same object.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">posted</tt></dt>
<dd><p>Array used internally to store the post history so that when new
listeners express interests in this signal, they can be informed
of the signals that have been posted so far. This can be cleared
using the signal&#8217;s <a class="reference internal" href="message.html#Clear" title="Clear"><tt class="xref py py-meth docutils literal"><span class="pre">Clear()</span></tt></a> method.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">listeners</tt></dt>
<dd><p>Array of callbacks to the listeners who have expressed interest in
hearing about posts to this signal. When a post occurs, the
listeners are called, each in turn, passing them the message that
was posted.</p>
</dd></dl>
</div>
<div class="section" id="methods">
<h2>Methods<a class="headerlink" href="#methods" title="Permalink to this headline"></a></h2>
<dl class="method">
<dt id="Post">
<tt class="descname">Post</tt><big>(</big><em>message</em><span class="optional">[</span>, <em>callback</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Post" title="Permalink to this definition"></a></dt>
<dd><p>Posts a message to all the listeners for the signal. The listener
callbacks are called in turn (with the message as an argument),
and if any return a <cite>Callback</cite> object, the posting will be
suspended until the callback is executed. In this way, the
<a class="reference internal" href="#Post" title="Post"><tt class="xref py py-meth docutils literal"><span class="pre">Post()</span></tt></a> call can operate asynchronously, and so the
<cite>callback</cite> parameter is used to synchronize with its operation;
the <cite>callback</cite> will be called when all the listeners have responded
to the post.</p>
<p>If a <a class="reference internal" href="#Post" title="Post"><tt class="xref py py-meth docutils literal"><span class="pre">Post()</span></tt></a> to this signal occurs while waiting for the
response from a listener (either because a listener returned a
<cite>Callback</cite> object and we are waiting for it to complete when the
<a class="reference internal" href="#Post" title="Post"><tt class="xref py py-meth docutils literal"><span class="pre">Post()</span></tt></a> occurred, or because the listener itself called the
<tt class="docutils literal"><span class="pre">Post()</span></tt> method), the new message will be queued and will be
posted after the current message has been sent to all the
listeners, and they have all responded. This is another way in
which posting can be asynchronous; the only sure way to know that
a posting has occurred is through its <cite>callback</cite>. When the posting
is complete, the callback is called, passing it the signal object
that has just completed.</p>
<p>Returns the callback object (or a blank callback object if none
was provided).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>message</strong> &#8212; the message to send through the signal</li>
<li><strong>callback</strong> &#8212; called after the message is posted</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback or a blank callback</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt>
<tt class="descname">Clear</tt><big>(</big><span class="optional">[</span><em>callback</em><span class="optional">]</span><big>)</big></dt>
<dd><p>This causes the history of past messages to be cleared so new
listeners will not receive them. Note that since the signal may
be operating asynchronously, the <a class="reference internal" href="message.html#Clear" title="Clear"><tt class="xref py py-meth docutils literal"><span class="pre">Clear()</span></tt></a> may be queued for
later. In this way, the <a class="reference internal" href="#Post" title="Post"><tt class="xref py py-meth docutils literal"><span class="pre">Post()</span></tt></a> and <a class="reference internal" href="message.html#Clear" title="Clear"><tt class="xref py py-meth docutils literal"><span class="pre">Clear()</span></tt></a>
operations will be performed in the proper order even when they
are delayed. The <cite>callback</cite> is called when the <a class="reference internal" href="message.html#Clear" title="Clear"><tt class="xref py py-meth docutils literal"><span class="pre">Clear()</span></tt></a>
operation is completed.</p>
<p>Returns the callback (or a blank callback if none is provided).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; called after the signal history is cleared</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback or a blank callback</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="Interest">
<tt class="descname">Interest</tt><big>(</big><em>callback</em><span class="optional">[</span>, <em>ignorePast</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#Interest" title="Permalink to this definition"></a></dt>
<dd><p>This method registers a new listener on the signal. It creates a
<cite>Callback</cite> object from the callback specification, attaches it to
the signal, and returns that <cite>Callback</cite> object. When new messages
are posted to the signal, it runs the callback, passing it the
message that was posted. If the callback itself returns a
<cite>Callback</cite> object, that indicates that the listener has started an
asynchronous operation and the poster should wait for that
callback to complete before allowing new posts on the signal.</p>
<p>If <cite>ignorePast</cite> is <tt class="docutils literal"><span class="pre">false</span></tt> or not present, then before
<a class="reference internal" href="#Interest" title="Interest"><tt class="xref py py-meth docutils literal"><span class="pre">Interest()</span></tt></a> returns, the callback will be called with all
the past messages that have been sent to the signal.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; called whenever a message is posted (past or present)</li>
<li><strong>ignorePast</strong> &#8212; <tt class="docutils literal"><span class="pre">true</span></tt> means ignore previous messages</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="NoInterest">
<tt class="descname">NoInterest</tt><big>(</big><em>callback</em><big>)</big><a class="headerlink" href="#NoInterest" title="Permalink to this definition"></a></dt>
<dd><p>This removes a listener from the signal so that no new messages
will be sent to it. The callback should be the one returned by
the original <a class="reference internal" href="#Interest" title="Interest"><tt class="xref py py-meth docutils literal"><span class="pre">Interest()</span></tt></a> call that attached the listener to
the signal in the first place. Once removed, the listener will no
longer receive messages from the signal.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>callback</strong> &#8212; the listener to be removed from signal</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="MessageHook">
<tt class="descname">MessageHook</tt><big>(</big><em>message</em>, <em>callback</em><big>)</big><a class="headerlink" href="#MessageHook" title="Permalink to this definition"></a></dt>
<dd><p>This creates a callback that is called whenever the signal posts
the given message. This is a little easier than having to write a
function that must check the message each time it is called.
Although the <cite>message</cite> here is a string, if a message posted to the
signal is an array, then only the first element of that array is
used to match against the message. That way, if a message contains an
identifier plus arguments, the hook will match the identifier and
still get called with the complete set of arguments.</p>
<p>Returns the <cite>Callback</cite> object that was produced.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>message</strong> &#8212; the message to look for from the signal</li>
<li><strong>callback</strong> &#8212; called when the message is posted</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last">the callback object</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="ExecuteHook">
<tt class="descname">ExecuteHook</tt><big>(</big><em>message</em><big>)</big><a class="headerlink" href="#ExecuteHook" title="Permalink to this definition"></a></dt>
<dd><p>Used internally to call the listeners when a particular
message is posted to the signal.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters :</th><td class="field-body"><ul class="first simple">
<li><strong>message</strong> &#8212; the posted message</li>
</ul>
</td>
</tr>
<tr class="field"><th class="field-name">Returns :</th><td class="field-body"><p class="first last"><tt class="docutils literal"><span class="pre">null</span></tt></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax.Callback.Signal Class</a><ul>
<li><a class="reference internal" href="#properties">Properties</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="queue.html"
title="previous chapter">The MathJax.Callback.Queue Class</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="inputjax.html"
title="next chapter">The MathJax.InputJax Class</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="inputjax.html" title="The MathJax.InputJax Class"
>next</a> |</li>
<li class="right" >
<a href="queue.html" title="The MathJax.Callback.Queue Class"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

231
docs/html/api/variable.html
View File

@ -1,231 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax variable &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="../_static/mj.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="../index.html" />
<link rel="up" title="The MathJax API" href="index.html" />
<link rel="next" title="The MathJax.Hub Object" href="hub.html" />
<link rel="prev" title="The MathJax API" href="index.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="hub.html" title="The MathJax.Hub Object"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="index.html" title="The MathJax API"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-variable">
<h1>The MathJax variable<a class="headerlink" href="#the-mathjax-variable" title="Permalink to this headline"></a></h1>
<p>MathJax has a single global variable, <tt class="docutils literal"><span class="pre">MathJax</span></tt>, in which all its
data, and the data for loaded components, are stored. The MathJax
variable is a nested structure, with its top-level properties being
objects themselves.</p>
<div class="section" id="main-mathjax-components">
<h2>Main MathJax Components<a class="headerlink" href="#main-mathjax-components" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Hub</tt></dt>
<dd><p>Contains the MathJax hub code and variables, including the startup
code, the onload handler, the browser data, and so forth.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Ajax</tt></dt>
<dd><p>Contains the code for loading external modules and creating
stylesheets. Most of the code that causes MathJax to
operate asynchronously is handled here.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Message</tt></dt>
<dd><p>Contains the code to handle the intermittent message window that
periodically appears in the lower left-hand corner of the window.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.HTML</tt></dt>
<dd><p>Contains support code for creating HTML elements dynamically from
descriptions stored in JavaScript objects.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.CallBack</tt></dt>
<dd><p>Contains the code for managing MathJax callbacks, queues and
signals.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Extension</tt></dt>
<dd><p>Initially empty, this is where extensions can load their code.
For example, the <cite>tex2jax</cite> preprocessor creates
<tt class="docutils literal"><span class="pre">MathJax.Extension.tex2jax</span></tt> for its code and variables.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Menu</tt></dt>
<dd><p>Initially null, this is where the MathJax contextual menu is
stored, when <tt class="docutils literal"><span class="pre">extensions/MathMenu.js</span></tt> is loaded.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.Object</tt></dt>
<dd><p>Contains the code for the MathJax object-oriented programming model.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.InputJax</tt></dt>
<dd><p>The base class for all input <cite>jax</cite> objects. Subclasses for
specific input jax are created as sub-objects of
<tt class="docutils literal"><span class="pre">MathJax.InputJax</span></tt>. For example, the TeX input jax loads itself
as <tt class="docutils literal"><span class="pre">MathJax.InputJax.TeX</span></tt>.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.OutputJax</tt></dt>
<dd><p>The base class for all output <cite>jax</cite> objects. Subclasses for
specific output jax are created as sub-objects of
<tt class="docutils literal"><span class="pre">MathJax.OutputJax</span></tt>. For example, the HTML-CSS output jax loads
itself as <tt class="docutils literal"><span class="pre">MathJax.OutputJax[&quot;HTML-CSS&quot;]</span></tt>.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.ElementJax</tt></dt>
<dd><p>The base class for all element <cite>jax</cite> objects. Subclasses for
specific element jax are created as sub-objects of
<tt class="docutils literal"><span class="pre">MathJax.ElementJax</span></tt>. For example, the mml element jax loads
itself as <tt class="docutils literal"><span class="pre">MathJax.ElementJax.mml</span></tt>.</p>
</dd></dl>
</div>
<div class="section" id="properties">
<h2>Properties<a class="headerlink" href="#properties" title="Permalink to this headline"></a></h2>
<dl class="describe">
<dt>
<tt class="descname">MathJax.version</tt></dt>
<dd><p>The version number of the MathJax library as a whole.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.fileversion</tt></dt>
<dd><p>The version number of the <tt class="docutils literal"><span class="pre">MathJax.js</span></tt> file specifically.</p>
</dd></dl>
<dl class="describe">
<dt>
<tt class="descname">MathJax.isReady</tt></dt>
<dd><p>This is set to <tt class="docutils literal"><span class="pre">true</span></tt> when MathJax is set up and ready to
perform typesetting actions (and is <tt class="docutils literal"><span class="pre">null</span></tt> otherwise).</p>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax variable</a><ul>
<li><a class="reference internal" href="#main-mathjax-components">Main MathJax Components</a></li>
<li><a class="reference internal" href="#properties">Properties</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="index.html"
title="previous chapter">The MathJax API</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="hub.html"
title="next chapter">The MathJax.Hub Object</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="hub.html" title="The MathJax.Hub Object"
>next</a> |</li>
<li class="right" >
<a href="index.html" title="The MathJax API"
>previous</a> |</li>
<li><a href="../index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="index.html" >The MathJax API</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

213
docs/html/asciimath.html
View File

@ -1,213 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>MathJax AsciiMath Support &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="next" title="MathJax Output Formats" href="output.html" />
<link rel="prev" title="MathJax MathML Support" href="mathml.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="output.html" title="MathJax Output Formats"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="mathml.html" title="MathJax MathML Support"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="mathjax-asciimath-support">
<span id="asciimath-support"></span><h1>MathJax AsciiMath Support<a class="headerlink" href="#mathjax-asciimath-support" title="Permalink to this headline"></a></h1>
<p>The support for <a class="reference internal" href="glossary.html#term-asciimath"><em class="xref std std-term">AsciiMath</em></a> in MathJax consists of two parts:
the <cite>asciimath2jax</cite> preprocessor, and the <cite>AsciiMath</cite> input processor.
The first of these looks for mathematics within your web page
(indicated by delimiters like <tt class="docutils literal"><span class="pre">`...`</span></tt>) and marks the mathematics for
later processing by MathJax. The AsciiMath input processor is what
converts the AsciiMath notation into MathJax&#8217;s internal format, where
one of MathJax&#8217;s output processors then displays it in the web page.</p>
<p>The AsciiMath input jax actually includes a copy of Peter Jipsen&#8217;s
<tt class="docutils literal"><span class="pre">ASCIIMathML.js</span></tt> file (see the <a class="reference external" href="http://www1.chapman.edu/~jipsen/mathml/asciimath.html">AsciiMath home page</a> for
details), and is included by permission of the author. This means
that the results of MathJax&#8217;s AsciiMath processing should be the same
as using the actual <tt class="docutils literal"><span class="pre">ASCIIMathML.js</span></tt> package (at least as far as the
MathML that it generates is concerned). Thanks go to David Lippman
for writing the initial version of the AsciiMath preprocessor and
input jax.</p>
<p>The <cite>asciimath2jax</cite> preprocessor can be configured to look for whatever
markers you want to use for your math delimiters. See the
<a class="reference internal" href="options/asciimath2jax.html#configure-asciimath2jax"><em>asciimath2jax configuration options</em></a> section for
details on how to customize the action of <cite>asciimath2jax</cite>.</p>
<p>The AsciiMath input processor handles conversion of your mathematical
notation into MathJax&#8217;s internal format (which is essentially MathML).
The AsciiMath input processor has few configuration options (see the
<a class="reference internal" href="options/AsciiMath.html#configure-asciimath"><em>AsciiMath options</em></a> section for details).</p>
<p>The AsciiMath input jax handles only the original ASCIIMathML notation
(from ASCIIMathML v1.4.7), not the extened LaTeXMathML notation added
in version 2.0 of ASCIIMathML, though the AsciiMath input jax does
expose the tables that define the symbols that AsciiMath processes,
and so it would be possible to extend them to include additional
symbols. In general, it is probably better to use MathJax&#8217;s <a class="reference internal" href="tex.html#tex-support"><em>TeX
input jax</em></a> to handle LaTeX notation instead.</p>
<div class="section" id="asciimath-delimiters">
<h2>AsciiMath delimiters<a class="headerlink" href="#asciimath-delimiters" title="Permalink to this headline"></a></h2>
<p>By default, the <cite>asciimath2jax</cite> preprocessor defines the back-tick
(<tt class="docutils literal"><span class="pre">`</span></tt>) as the delimiters for mathematics in AsciiMath format. It
does <strong>not</strong> define <tt class="docutils literal"><span class="pre">$...$</span></tt> as math delimiters. That is because
dollar signs appear too often in non-mathematical settings, which
could cause some text to be treated as mathematics unexpectedly. For
example, with single-dollar delimiters, &#8221;... the cost is $2.50 for the
first one, and $2.00 for each additional one ...&#8221; would cause the
phrase &#8220;2.50 for the first one, and&#8221; to be treated as mathematics
since it falls between dollar signs. For this reason, if you want to
use single-dollars for AsciiMath notation, you must enable that
explicitly in your configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">asciimath2jax</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">delimiters</span><span class="o">:</span> <span class="p">[[</span><span class="s1">&#39;$&#39;</span><span class="p">,</span><span class="s1">&#39;$&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;`&#39;</span><span class="p">,</span><span class="s1">&#39;`&#39;</span><span class="p">]]</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>Note that the dollar signs are frequently used as a delimiter for
mathematics in the <a class="reference internal" href="glossary.html#term-tex"><em class="xref std std-term">TeX</em></a> format, and you can not enable the
dollar-sign delimiter for both. It is probably best to leave dollar
signs for TeX notation.</p>
<p>See the <tt class="docutils literal"><span class="pre">config/default.js</span></tt> file, or the <a class="reference internal" href="options/asciimath2jax.html#configure-asciimath2jax"><em>asiimath2jax
configuration options</em></a> page, for additional
configuration parameters that you can specify for the <cite>asciimath2jax</cite>
preprocessor, which is the component of MathJax that identifies
AsciiMath notation within the page.</p>
</div>
<div class="section" id="asciimath-in-html-documents">
<h2>AsciiMath in HTML documents<a class="headerlink" href="#asciimath-in-html-documents" title="Permalink to this headline"></a></h2>
<p>The AsciiMath syntax is descibed in the <a class="reference external" href="http://www1.chapman.edu/~jipsen/mathml/asciimathsyntax.html">ASCIIMathML syntax page</a>.</p>
<p>Keep in mind that your mathematics is part of an HTML document, so you
need to be aware of the special characters used by HTML as part of its
markup. There cannot be HTML tags within the math delimiters (other
than <tt class="docutils literal"><span class="pre">&lt;BR&gt;</span></tt>) as AsciiMath-formatted math does not include HTML tags.
Also, since the mathematics is initially given as text on the page,
you need to be careful that your mathematics doesn&#8217;t look like HTML
tags to the browser (which parses the page before MathJax gets to see
it). In particular, that means that you have to be careful about
things like less-than and greater-than signs (<tt class="docutils literal"><span class="pre">&lt;</span></tt> and <tt class="docutils literal"><span class="pre">&gt;</span></tt>), and
ampersands (<tt class="docutils literal"><span class="pre">&amp;</span></tt>), which have special meaning to the browsers. For
example,</p>
<div class="highlight-html"><pre>... when `x&lt;y` we have ...</pre>
</div>
<p>will cause a problem, because the brower will think <tt class="docutils literal"><span class="pre">&lt;y</span></tt> is the
beginning of a tag named <tt class="docutils literal"><span class="pre">y</span></tt> (even though there is no such tag in
HTML). When this happens, the browser will think the tag continues up
to the next <tt class="docutils literal"><span class="pre">&gt;</span></tt> in the document (typically the end of the next
actual tag in the HTML file), and you may notice that you are missing
part of the text of the document. In the example above, the &#8220;<tt class="docutils literal"><span class="pre">we</span>
<span class="pre">have</span> <span class="pre">...</span></tt>&#8221; will not be displayed because the browser thinks it is
part of the tag starting at <tt class="docutils literal"><span class="pre">&lt;y</span></tt>. This is one indication you can
use to spot this problem; it is a common error and should be avoided.</p>
<p>Usually, it is sufficient to simply put spaces around these symbols to
cause the browser to avoid them, so</p>
<div class="highlight-html"><pre>... when `x &lt; y` we have ...</pre>
</div>
<p>should work. Alternatively, you can use the HTML entities <tt class="docutils literal"><span class="pre">&amp;lt;</span></tt>,
<tt class="docutils literal"><span class="pre">&amp;gt;</span></tt> and <tt class="docutils literal"><span class="pre">&amp;amp;</span></tt> to encode these characters so that the browser
will not interpret them, but MathJax will. E.g.,</p>
<div class="highlight-html"><div class="highlight"><pre>... when `x <span class="ni">&amp;lt;</span> y` we have ...
</pre></div>
</div>
<p>Keep in mind that the browser interprets your text before MathJax
does.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">MathJax AsciiMath Support</a><ul>
<li><a class="reference internal" href="#asciimath-delimiters">AsciiMath delimiters</a></li>
<li><a class="reference internal" href="#asciimath-in-html-documents">AsciiMath in HTML documents</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="mathml.html"
title="previous chapter">MathJax MathML Support</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="output.html"
title="next chapter">MathJax Output Formats</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="output.html" title="MathJax Output Formats"
>next</a> |</li>
<li class="right" >
<a href="mathml.html" title="MathJax MathML Support"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

303
docs/html/callbacks.html
View File

@ -1,303 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Using Callbacks &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="up" title="Synchronizing your code with MathJax" href="synchronize.html" />
<link rel="next" title="Using Queues" href="queues.html" />
<link rel="prev" title="Synchronizing your code with MathJax" href="synchronize.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="queues.html" title="Using Queues"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="synchronize.html" title="Synchronizing your code with MathJax"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="synchronize.html" accesskey="U">Synchronizing your code with MathJax</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="using-callbacks">
<span id="id1"></span><h1>Using Callbacks<a class="headerlink" href="#using-callbacks" title="Permalink to this headline"></a></h1>
<p>A &#8220;callback&#8221; is a function that MathJax calls when it completes an
action that may occur asynchronously (like loading a file). Many of
MathJax&#8217;s functions operate asynchronously, and MathJax uses callbacks
to allow you to synchronize your code with the action of those
functions. The <cite>MathJax.Callback</cite> structure manages these callbacks.
Callbacks can include not only a function to call, but also data to be
passed to the function, and an object to act as the JavaScript <cite>this</cite>
value in the resulting call (i.e., the object on which the callback is
to execute).</p>
<p>Callbacks can be collected into <a class="reference internal" href="queues.html#using-queues"><em>Queues</em></a> where the
callbacks will be processed in order, with later callbacks waiting
until previous ones have completed before they are called. They are
also used with <a class="reference internal" href="signals.html#using-signals"><em>Signals</em></a> as the means of
receiving information about the signals as they occur.</p>
<p>A number of methods in <cite>MathJax.Hub</cite> and <cite>MathJax.Ajax</cite> accept
callback specifications as arguments and return callback structures.
These routines always will return a callback even when none was
specified in the arguments, and in that case, the callback is a &#8220;do
nothing&#8221; callback. The reason for this is so that the resulting
callback can be used in a <cite>MathJax.Callback.Queue</cite> for synchronization
purposes, so that the actions following it in the queue will not be
performed until after the callback has been fired.</p>
<p>For example, the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> method can be used to
load external files, and it returns a callback that is called when the
file has been loaded and executed. If you want to load several files
and wait for them all to be loaded before performing some action, you
can create a <cite>Queue</cite> into which you push the results of the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> calls, and then push a callback for the
action. The final action will not be performed until all the
file-load callbacks (which precede it in the queue) have been called;
i.e., the action will not occur until all the files are loaded.</p>
<div class="section" id="specifying-a-callback">
<h2>Specifying a Callback<a class="headerlink" href="#specifying-a-callback" title="Permalink to this headline"></a></h2>
<p>Callbacks can be specified in a number of different ways, depending on
the functionality that is required of the callback. The easiest case
is to simply provide a function to be called, but it is also possible
to include data to pass to the function when it is called, and to
specify the object that will be used as <cite>this</cite> when the function is
called.</p>
<p>For example, the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> method can accept a
callback as its second argument (it will be called when the file given
as the first argument is loaded and executed). So you can call</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="s2">&quot;[MathJax]/config/myConfig.js&quot;</span><span class="p">,</span><span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
<span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;My configuration file is loaded&quot;</span><span class="p">);</span>
<span class="p">});</span>
</pre></div>
</div>
<p>and an alert will appear when the file is loaded. An example of
passing arguments to the callback function includes the following:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">function</span> <span class="nx">loadHook</span> <span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;loadHook: &quot;</span><span class="o">+</span><span class="nx">x</span><span class="p">)}</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="s2">&quot;[MathJax]/config/myConfig.js&quot;</span><span class="p">,[</span><span class="nx">loadHook</span><span class="p">,</span><span class="s2">&quot;myConfig&quot;</span><span class="p">]);</span>
</pre></div>
</div>
<p>Here, the <tt class="docutils literal"><span class="pre">loadHook()</span></tt> function accepts one argument and generates
an alert that includes the value passed to it. The callback in the
<tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> call is <tt class="docutils literal"><span class="pre">[loadHook,&quot;myConfig&quot;]</span></tt>,
which means that (the equivalent of) <tt class="docutils literal"><span class="pre">loadHook(&quot;myConfig&quot;)</span></tt> will be
performed when the file is loaded. The result should be an alert with
the text <cite>loadHook: myConfig</cite>.</p>
<p>The callback for the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Ajax.Require()</span></tt> method actually
gets called with a status value, in addition to any parameters already
included in the callback specification, that indicates whether the
file loaded successfully, or failed for some reason (perhaps the file
couldn&#8217;t be found, or it failed to compile and run). So you could use</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="s2">&quot;[MathJax]/config/myConfig.js&quot;</span><span class="p">,</span><span class="kd">function</span> <span class="p">(</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">status</span> <span class="o">===</span> <span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">STATUS</span><span class="p">.</span><span class="nx">OK</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;My configuration file is loaded&quot;</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;My configuration file failed to load!&quot;</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>to check if the file loaded properly. With additional parameters, the
example might be</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">function</span> <span class="nx">loadHook</span> <span class="p">(</span><span class="nx">x</span><span class="p">,</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span><span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;loadHook: &quot;</span><span class="o">+</span><span class="nx">x</span><span class="o">+</span><span class="s2">&quot; has status &quot;</span><span class="o">+</span><span class="nx">status</span><span class="p">)}</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="s2">&quot;[MathJax]/config/myConfig.js&quot;</span><span class="p">,[</span><span class="nx">loadHook</span><span class="p">,</span><span class="s2">&quot;myConfig&quot;</span><span class="p">]);</span>
</pre></div>
</div>
<p>Note that the parameters given in the callback specification are used
first, and then additional parameters from the call to the callback
come afterward.</p>
<div class="section" id="callbacks-to-object-methods">
<h3>Callbacks to Object Methods<a class="headerlink" href="#callbacks-to-object-methods" title="Permalink to this headline"></a></h3>
<p>When you use a method of a JavaScript object, a special variable
called <cite>this</cite> is defined that refers to the object whose method is
being called. It allows you to access other methods or properties of
the object without knowing explicitly where the object is stored.</p>
<p>For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">aPerson</span> <span class="o">=</span> <span class="p">{</span>
<span class="nx">firstname</span><span class="o">:</span> <span class="s2">&quot;John&quot;</span><span class="p">,</span>
<span class="nx">lastname</span><span class="o">:</span> <span class="s2">&quot;Smith&quot;</span><span class="p">,</span>
<span class="nx">showName</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span><span class="nx">alert</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">firstname</span><span class="o">+</span><span class="s2">&quot; &quot;</span><span class="o">+</span><span class="k">this</span><span class="p">.</span><span class="nx">lastname</span><span class="p">)}</span>
<span class="p">};</span>
</pre></div>
</div>
<p>creates an object that contains three items, a <cite>firstname</cite>, and
<cite>lastname</cite>, and a method that shows the person&#8217;s full name in an
alert. So <tt class="docutils literal"><span class="pre">aPerson.showName()</span></tt> would cause an alert with the text
<tt class="docutils literal"><span class="pre">John</span> <span class="pre">Smith</span></tt> to appear. Note, however that this only works if the
method is called as <tt class="docutils literal"><span class="pre">aPerson.showName()</span></tt>; if instead you did</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">f</span> <span class="o">=</span> <span class="nx">aPerson</span><span class="p">.</span><span class="nx">showName</span><span class="p">;</span> <span class="c1">// assign f the function from aPerson</span>
<span class="nx">f</span><span class="p">();</span> <span class="c1">// and call the function</span>
</pre></div>
</div>
<p>the association of the function with the data in <tt class="docutils literal"><span class="pre">aPerson</span></tt> is lost,
and the alert will probably show <tt class="docutils literal"><span class="pre">undefined</span> <span class="pre">undefined</span></tt>. (In this
case, <tt class="docutils literal"><span class="pre">f</span></tt> will be called with <tt class="docutils literal"><span class="pre">this</span></tt> set to the <tt class="docutils literal"><span class="pre">window</span></tt>
variable, and so <tt class="docutils literal"><span class="pre">this.firstname</span></tt> and <tt class="docutils literal"><span class="pre">this.lastname</span></tt> will refer
to undefined values.)</p>
<p>Because of this, it is difficult to use an object&#8217;s method as a
callback if you refer to it as a function directly. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">var</span> <span class="nx">aFile</span> <span class="o">=</span> <span class="p">{</span>
<span class="nx">name</span><span class="o">:</span> <span class="s2">&quot;[MathJax]/config/myConfig.js&quot;</span><span class="p">,</span>
<span class="nx">onload</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">alert</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">name</span><span class="o">+</span><span class="s2">&quot; is loaded with status &quot;</span><span class="o">+</span><span class="nx">status</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">};</span>
<span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="nx">aFile</span><span class="p">.</span><span class="nx">name</span><span class="p">,</span><span class="nx">aFile</span><span class="p">.</span><span class="nx">onload</span><span class="p">);</span>
</pre></div>
</div>
<p>would produce an alert indicating that &#8220;undefined&#8221; was loaded with a
particular status. That is because <tt class="docutils literal"><span class="pre">aFile.onload</span></tt> is a reference to
the <cite>onload</cite> method, which is just a function, and the association
with the <cite>aFile</cite> object is lost. One could do</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="nx">aFile</span><span class="p">.</span><span class="nx">name</span><span class="p">,</span><span class="kd">function</span> <span class="p">(</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span><span class="nx">aFile</span><span class="p">.</span><span class="nx">onload</span><span class="p">(</span><span class="nx">status</span><span class="p">)});</span>
</pre></div>
</div>
<p>but that seems needlessly verbose, and it produces a closure when one
is not really needed. Instead, MathJax provides an alternative
specification for a callback that allows you to specify both the
method and the object it comes from:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="nx">aFile</span><span class="p">.</span><span class="nx">name</span><span class="p">,[</span><span class="s2">&quot;onload&quot;</span><span class="p">,</span><span class="nx">aFile</span><span class="p">]);</span>
</pre></div>
</div>
<p>This requests that the callback should call <tt class="docutils literal"><span class="pre">aFile.onload</span></tt> as the
function, which will maintain the connection between <tt class="docutils literal"><span class="pre">aFile</span></tt> and its
method, thus preserving the correct value for <cite>this</cite> within the method.</p>
<p>As in the previous cases, you can pass parameters to the method as
well by including them in the array that specifies the callback:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Ajax</span><span class="p">.</span><span class="nx">Require</span><span class="p">(</span><span class="s2">&quot;filename&quot;</span><span class="p">,[</span><span class="s2">&quot;method&quot;</span><span class="p">,</span><span class="nx">object</span><span class="p">,</span><span class="nx">arg1</span><span class="p">,</span><span class="nx">arg2</span><span class="p">,...]);</span>
</pre></div>
</div>
<p>This approach is useful when you are pushing a callback for one of
MathJax&#8217;s Hub routines into the MathJax processing queue. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Queue</span><span class="p">([</span><span class="s2">&quot;Typeset&quot;</span><span class="p">,</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">,</span><span class="s2">&quot;MathDiv&quot;</span><span class="p">]);</span>
</pre></div>
</div>
<p>pushes the equivalent of <tt class="docutils literal"><span class="pre">MathJax.Hub.Typeset(&quot;MathDiv&quot;)</span></tt> into the
processing queue.</p>
<p>See the <a class="reference internal" href="api/callback.html#api-callback"><em>Callback Object</em></a> reference pages for more
information about the valid methods of specifying a callback.</p>
</div>
<div class="section" id="creating-a-callback-explicitly">
<h3>Creating a Callback Explicitly<a class="headerlink" href="#creating-a-callback-explicitly" title="Permalink to this headline"></a></h3>
<p>When you call a method that accepts a callback, you usually pass it a
callback specification (like in the examples above), which <em>describes</em>
a callback (the method will create the actual <cite>Callback</cite> object, and
return that to you as its return value). You don&#8217;t usually create
<cite>Callback</cite> objects directly yourself.</p>
<p>There are times, however, when you may wish to create a callback
object for use with functions that don&#8217;t create callbacks for you.
For example, the <tt class="docutils literal"><span class="pre">setTimeout()</span></tt> function can take a function as its
argument, and you may want that function to be a method of an object,
and would run into the problem described in the previous section if
you simply passed the object&#8217;s method to <tt class="docutils literal"><span class="pre">setTimeout()</span></tt>. Or you
might want to pass an argument to the function called by
<tt class="docutils literal"><span class="pre">setTimeout()</span></tt>. (Altough the <tt class="docutils literal"><span class="pre">setTimeout()</span></tt> function can accept
additional arguements that are supposed to be passed on to the code
when it is called, some versions of Internet Explorer do not implement
that feature, so you can&#8217;t rely on it.) You can use a <cite>Callback</cite>
object to do this, and the <tt class="xref py py-meth docutils literal"><span class="pre">MathJax.Callback()</span></tt> method will
create one for you. For example,</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="kd">function</span> <span class="nx">f</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span><span class="nx">alert</span><span class="p">(</span><span class="s2">&quot;x = &quot;</span><span class="o">+</span><span class="nx">x</span><span class="p">)}</span>
<span class="nx">setTimeout</span><span class="p">(</span><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Callback</span><span class="p">([</span><span class="nx">f</span><span class="p">,</span><span class="s2">&quot;Hello World!&quot;</span><span class="p">]),</span><span class="mi">500</span><span class="p">);</span>
</pre></div>
</div>
<p>would create a callback that calls <tt class="docutils literal"><span class="pre">f(&quot;Hello</span> <span class="pre">World!&quot;)</span></tt>, and
schedules it to be called in half a second.</p>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Using Callbacks</a><ul>
<li><a class="reference internal" href="#specifying-a-callback">Specifying a Callback</a><ul>
<li><a class="reference internal" href="#callbacks-to-object-methods">Callbacks to Object Methods</a></li>
<li><a class="reference internal" href="#creating-a-callback-explicitly">Creating a Callback Explicitly</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="synchronize.html"
title="previous chapter">Synchronizing your code with MathJax</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="queues.html"
title="next chapter">Using Queues</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="queues.html" title="Using Queues"
>next</a> |</li>
<li class="right" >
<a href="synchronize.html" title="Synchronizing your code with MathJax"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
<li><a href="synchronize.html" >Synchronizing your code with MathJax</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

153
docs/html/community.html
View File

@ -1,153 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The MathJax Community &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="next" title="What’s New in MathJax v2.0" href="whats-new-2.0.html" />
<link rel="prev" title="MathJax Output Formats" href="output.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="whats-new-2.0.html" title="What’s New in MathJax v2.0"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="output.html" title="MathJax Output Formats"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="the-mathjax-community">
<h1>The MathJax Community<a class="headerlink" href="#the-mathjax-community" title="Permalink to this headline"></a></h1>
<p>If you are an active MathJax user, you may wish to become involved in
the wider community of MathJax users. The MathJax project maintains
forums where users can ask questions about how to use MathJax, make
suggestions about future features for MathJax, and present their own
solutions to problems that they have faced. There is also a
bug-tracking system where you can report errors that you have found
with MathJax in your environment.</p>
<div class="section" id="forums">
<span id="community-forums"></span><h2>Forums<a class="headerlink" href="#forums" title="Permalink to this headline"></a></h2>
<p>If you need help using MathJax or you have solutions you want to share, please
use the <a class="reference external" href="http://groups.google.com/group/mathjax-users">MathJax Users Google Group</a>. We try hard to answer
questions quickly, and users are welcome to help with that as well. Also, users
can post code snippets showing how they have used MathJax, so it may be a good
place to find the examples you are looking for.</p>
<p>If you want to discuss MathJax development, please use the <a class="reference external" href="http://groups.google.com/group/mathjax-dev">MathJax Dev Google
Group</a>. We made this group
to discuss anything beyond what an end-user might be interested in, so if you
have any suggestions or questions about MathJax performance, technology, or
design, feel free to submit it to the group.</p>
<p>The community is only as good as the users who participate, so if
you have something to offer, please take time to make a post on one of
our groups.</p>
</div>
<div class="section" id="issue-tracking">
<span id="community-tracker"></span><h2>Issue tracking<a class="headerlink" href="#issue-tracking" title="Permalink to this headline"></a></h2>
<p>Found a bug or want to suggest an improvement? Post it to our <a class="reference external" href="http://github.com/mathjax/MathJax/issues">issue tracker</a>. We monitor the tracker closely,
and work hard to respond to problems quickly.</p>
<p>Before you create a new issue, however, please search the issues to see if it
has already been reported. You could also be using an outdated version of
MathJax, so be sure to <a class="reference internal" href="installation.html#getting-mathjax-git"><em>upgrade your copy</em></a> to verify
that the problem persists in the latest version.</p>
</div>
<div class="section" id="powered-by-mathjax">
<span id="badge"></span><h2>&#8220;Powered by MathJax&#8221;<a class="headerlink" href="#powered-by-mathjax" title="Permalink to this headline"></a></h2>
<p>If you are using MathJax and want to show your support, please consider using
our <a class="reference external" href="http://www.mathjax.org/community/mathjax-badge">&#8220;Powered by MathJax&#8221; badge</a>.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">The MathJax Community</a><ul>
<li><a class="reference internal" href="#forums">Forums</a></li>
<li><a class="reference internal" href="#issue-tracking">Issue tracking</a></li>
<li><a class="reference internal" href="#powered-by-mathjax">&#8220;Powered by MathJax&#8221;</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="output.html"
title="previous chapter">MathJax Output Formats</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="whats-new-2.0.html"
title="next chapter">What&#8217;s New in MathJax v2.0</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="whats-new-2.0.html" title="What’s New in MathJax v2.0"
>next</a> |</li>
<li class="right" >
<a href="output.html" title="MathJax Output Formats"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

404
docs/html/config-files.html
View File

@ -1,404 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Common Configurations &mdash; MathJax v2.0 documentation</title>
<link rel="stylesheet" href="_static/mj.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<!--<script type="text/javascript" src="../../MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>-->
<link rel="top" title="MathJax v2.0 documentation" href="index.html" />
<link rel="next" title="Configuration Objects" href="options/index.html" />
<link rel="prev" title="Loading and Configuring MathJax" href="configuration.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="options/index.html" title="Configuration Objects"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="configuration.html" title="Loading and Configuring MathJax"
accesskey="P">previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="common-configurations">
<span id="id1"></span><h1>Common Configurations<a class="headerlink" href="#common-configurations" title="Permalink to this headline"></a></h1>
<p>MathJax comes with a number of pre-defined configuration files in the
<tt class="docutils literal"><span class="pre">MathJax/config</span></tt> directory. The <tt class="docutils literal"><span class="pre">default.js</span></tt> file contains nearly all
the possible configuration options together with comments explaining them,
so you can use that file to customize MathJax to your needs. Simply load
it via</p>
<div class="highlight-html"><div class="highlight"><pre><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span> <span class="na">src=</span><span class="s">&quot;path-to-MathJax/MathJax.js?config=default&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</pre></div>
</div>
<p>where <tt class="docutils literal"><span class="pre">path-to-MathJax</span></tt> is the URL to the MathJax directory on your
server or hard disk. If you are using MathJax from the CDN, you can
view the contents of <a class="reference external" href="http://cdn.mathjax.org/mathjax/latest/config/default.js">default.js</a> as a
reference, but you will not be able to edit the CDN copy. It is
possible to use the CDN copy of MathJax with your own configuration
file, however; see <a class="reference internal" href="configuration.html#local-config-files"><em>Using a Local Configuration File with the CDN</em></a> for details.</p>
<p>The remaining files in the <a class="reference external" href="http://cdn.mathjax.org/mathjax/latest/config/">MathJax/config</a> directory are
combined configuration files that include not just configuration
parameters but also the files that MathJax would need to load for
those configurations. This means MathJax will have to load fewer
files, and since each file access requires establishing connections
over the network, it can be faster to load one larger file than
several smaller ones. See <a class="reference internal" href="configuration.html#loading"><em>Loading and Configuring MathJax</em></a> for more details about how to load configurations, and how
to modify the parameters for a configuration file.</p>
<p>The following sections describe the contents of the combined configuration
files. Each comes in two flavors: a standard version and a &#8220;full&#8221; version.
The standard version simply defines the output processor(s) that are part
of the configuration, but doesn&#8217;t load the code that implements the output
processor. The full version loads the complete output processors, so
everything that MathJax needs for the page should be loaded up front, and
there will be no delay once the page is ready to be processed. To obtain
the &#8220;full&#8221; version, add <tt class="docutils literal"><span class="pre">-full</span></tt> to the end of the configuration file
name.</p>
<div class="section" id="the-tex-mml-am-htmlormml-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">TeX-MML-AM_HTMLorMML</span></tt> configuration file<a class="headerlink" href="#the-tex-mml-am-htmlormml-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is the most general of the pre-defined
configurations. It loads all the main MathJax components, including
the TeX, MathML, and AsciiMath preprocessors and input processors, the
AMSmath, AMSsymbols, noErrors, and noUndefined TeX extensions, both
the native MathML and HTML-with-CSS output processor definitions, and
the MathMenu and MathZoom extensions. It is equivalent to the
following configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">config</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;MMLorHTML.js&quot;</span><span class="p">],</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/TeX&quot;</span><span class="p">,</span><span class="s2">&quot;input/MathML&quot;</span><span class="p">,</span><span class="s2">&quot;input/AsciiMath&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">,</span><span class="s2">&quot;output/NativeMML&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;tex2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;mml2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;asciimath2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">],</span>
<span class="nx">TeX</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;AMSmath.js&quot;</span><span class="p">,</span><span class="s2">&quot;AMSsymbols.js&quot;</span><span class="p">,</span><span class="s2">&quot;noErrors.js&quot;</span><span class="p">,</span><span class="s2">&quot;noUndefined.js&quot;</span><span class="p">]</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax, the TeX, MathML, and
AsciiMath input jax main code (not just the definition files), as well
as the <cite>toMathML</cite> extension, which is used by the Show Source option
in the MathJax contextual menu. The <cite>-full</cite> version also loads both the
HTML-CSS and NativeMML output jax main code, plus the HTML-CSS
<cite>mtable</cite> extension, which is normally loaded on demand.</p>
<p>See the <a class="reference internal" href="options/tex2jax.html#configure-tex2jax"><em>tex2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">tex2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/TeX.html#configure-tex"><em>TeX input jax configuration</em></a> section for options
that control the TeX input processor.
See the <a class="reference internal" href="options/mml2jax.html#configure-mml2jax"><em>mml2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">mml2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/MathML.html#configure-mathml"><em>MathML input jax configuration</em></a> section for
options that control the MathML input processor.
See the <a class="reference internal" href="options/asciimath2jax.html#configure-asciimath2jax"><em>asciimath2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">asciimath2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/AsciiMath.html#configure-asciimath"><em>AsciiMath input jax configuration</em></a> section for
options that control the AsciiMath input processor.
See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a> for more
information on the NativeMML and HTML-CSS output processors. See the
<a class="reference internal" href="options/MMLorHTML.html#configure-mmlorhtml"><em>MMLorHTML configuration</em></a> section for
details on the options that control the <tt class="docutils literal"><span class="pre">MMLorHTML</span></tt> configuration.</p>
</div>
<div class="section" id="the-tex-ams-mml-htmlormml-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">TeX-AMS-MML_HTMLorMML</span></tt> configuration file<a class="headerlink" href="#the-tex-ams-mml-htmlormml-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is the most commonly used of the pre-defined
configurations. It loads all the main MathJax components, including
the TeX and MathML preprocessors and input processors, the AMSmath,
AMSsymbols, noErrors, and noUndefined TeX extensions, both the native
MathML and HTML-with-CSS output processor definitions, and the
MathMenu and MathZoom extensions. It is equivalent to the following
configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">config</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;MMLorHTML.js&quot;</span><span class="p">],</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/TeX&quot;</span><span class="p">,</span><span class="s2">&quot;input/MathML&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">,</span><span class="s2">&quot;output/NativeMML&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;tex2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;mml2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">],</span>
<span class="nx">TeX</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;AMSmath.js&quot;</span><span class="p">,</span><span class="s2">&quot;AMSsymbols.js&quot;</span><span class="p">,</span><span class="s2">&quot;noErrors.js&quot;</span><span class="p">,</span><span class="s2">&quot;noUndefined.js&quot;</span><span class="p">]</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax, the TeX and MathML input
jax main code (not just the definition files), as well as the
<cite>toMathML</cite> extension, which is used by the Show Source option in the
MathJax contextual menu. The <tt class="docutils literal"><span class="pre">-full</span></tt> version also loads both the
HTML-CSS and NativeMML output jax main code, plus the HTML-CSS
<cite>mtable</cite> extension, which is normally loaded on demand.</p>
<p>See the <a class="reference internal" href="options/tex2jax.html#configure-tex2jax"><em>tex2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">tex2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/TeX.html#configure-tex"><em>TeX input jax configuration</em></a> section for options
that control the TeX input processor.
See the <a class="reference internal" href="options/mml2jax.html#configure-mml2jax"><em>mml2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">mml2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/MathML.html#configure-mathml"><em>MathML input jax configuration</em></a> section for
options that control the MathML input processor.
See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a> for more
information on the NativeMML and HTML-CSS output processors. See the
<a class="reference internal" href="options/MMLorHTML.html#configure-mmlorhtml"><em>MMLorHTML configuration</em></a> section for
details on the options that control the <tt class="docutils literal"><span class="pre">MMLorHTML</span></tt> configuration.</p>
</div>
<div class="section" id="the-tex-ams-html-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">TeX-AMS_HTML</span></tt> configuration file<a class="headerlink" href="#the-tex-ams-html-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is for sites that only use TeX format for their
mathematics, and that want the output to be as close to TeX output as
possible. This uses the HTML-CSS output jax (even when the user&#8217;s browser
understands MathML). The user can still use the MathJax contextual menu
to select the NativeMML output jax if they desire.</p>
<p>This file includes all the important MathJax components for TeX input and
output, including the <cite>tex2jax</cite> preprocessor and TeX input jax, the
AMSmath, AMSsymbols, noErrors, and noUndefined TeX extensions, the
HTML-with-CSS output processor definition, and the MathMenu and MathZoom
extensions. It is equivalent to the following configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/TeX&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;tex2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">],</span>
<span class="nx">TeX</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;AMSmath.js&quot;</span><span class="p">,</span><span class="s2">&quot;AMSsymbols.js&quot;</span><span class="p">,</span><span class="s2">&quot;noErrors.js&quot;</span><span class="p">,</span><span class="s2">&quot;noUndefined.js&quot;</span><span class="p">]</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax and the TeX input jax main code
(not just the definition file), as well as the <cite>toMathML</cite> extension, which
is used by the Show Source option in the MathJax contextual menu. The <tt class="docutils literal"><span class="pre">-full</span></tt>
version also loads the HTML-CSS output jax main code, plus the HTML-CSS
<cite>mtable</cite> extension, which is normally loaded on demand.</p>
<p>See the <a class="reference internal" href="options/tex2jax.html#configure-tex2jax"><em>tex2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">tex2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/TeX.html#configure-tex"><em>TeX input jax configuration</em></a> section for options
that control the TeX input processor.
See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a> for more
information on the HTML-CSS output processor.</p>
</div>
<div class="section" id="the-mml-htmlormml-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">MML_HTMLorMML</span></tt> configuration file<a class="headerlink" href="#the-mml-htmlormml-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is for sites that only use MathML format for their
mathematics. It will use MathML output in browsers where that is
supported well, and HTML-CSS output otherwise. The user can still use the
MathJax contextual menu to select the other output format if they desire.</p>
<p>This file includes all the important MathJax components for MathML input
and output, including the <cite>mml2jax</cite> preprocessor and MathML input jax, the
NativeMML and HTML-CSS output processor definition files, and the MathMenu
and MathZoom extensions. It is equivalent to the following configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">config</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;MMLorHTML.js&quot;</span><span class="p">],</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/MathML&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">,</span><span class="s2">&quot;output/NativeMML&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;mml2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">]</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax and the MathML input jax main
code (not just the definition file), as well as the <cite>toMathML</cite> extension,
which is used by the Show Source option in the MathJax contextual menu.
The <tt class="docutils literal"><span class="pre">-full</span></tt> version also loads both the HTML-CSS and NativeMML output jax main
code files, plus the HTML-CSS <cite>mtable</cite> extension, which is normally loaded
on demand.</p>
<p>See the <a class="reference internal" href="options/mml2jax.html#configure-mml2jax"><em>mml2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">mml2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/MathML.html#configure-mathml"><em>MathML input jax configuration</em></a> section for
options that control the MathML input processor.
See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a> for more
information on the NativeMML and HTML-CSS output processors. See the
<a class="reference internal" href="options/MMLorHTML.html#configure-mmlorhtml"><em>MMLorHTML configuration</em></a> section for
details on the options that control the <tt class="docutils literal"><span class="pre">MMLorHTML</span></tt> configuration.</p>
</div>
<div class="section" id="the-am-htmlormml-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">AM_HTMLorMML</span></tt> configuration file<a class="headerlink" href="#the-am-htmlormml-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is for sites that only use AsciiMath format for their
mathematics. It will use MathML output in browsers where that is
supported well, and HTML-CSS output otherwise. The user can still use the
MathJax contextual menu to select the other output format if they desire.</p>
<p>This file includes all the important MathJax components for AsciiMath
input and output, including the <cite>asciimath2jax</cite> preprocessor and
AsciiMath input jax, the NativeMML and HTML-CSS output processor
definition files, and the MathMenu and MathZoom extensions. It is
equivalent to the following configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">config</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;MMLorHTML.js&quot;</span><span class="p">],</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/AsciiMath&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">,</span><span class="s2">&quot;output/NativeMML&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;asciimath2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">]</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax and the TeX input jax main code
(not just the definition file), as well as the <cite>toMathML</cite> extension, which
is used by the Show Source option in the MathJax contextual menu. The <tt class="docutils literal"><span class="pre">-full</span></tt>
version also loads the HTML-CSS output jax main code, plus the HTML-CSS
<cite>mtable</cite> extension, which is normally loaded on demand.</p>
<p>See the <a class="reference internal" href="options/asciimath2jax.html#configure-asciimath2jax"><em>asciimath2jax configuration</em></a>
section for other configuration options for the <tt class="docutils literal"><span class="pre">asciimath2jax</span></tt>
preprocessor, and the <a class="reference internal" href="options/AsciiMath.html#configure-asciimath"><em>AsciiMath input jax configuration</em></a> section for options that control the AsciiMath
input processor. See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a>
for more information on the HTML-CSS and NativeMML output processors.
See the <a class="reference internal" href="options/MMLorHTML.html#configure-mmlorhtml"><em>MMLorHTML configuration</em></a> section
for details on the options that control the <tt class="docutils literal"><span class="pre">MMLorHTML</span></tt>
configuration.</p>
</div>
<div class="section" id="the-tex-ams-mml-svg-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">TeX-AMS-MML_SVG</span></tt> configuration file<a class="headerlink" href="#the-tex-ams-mml-svg-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is the same as <cite>TeX-AMS-MML_HTMLorMML</cite> except
that it uses the SVG output renderer rather than the NativeMML or
HTML-CSS ones. It loads all the main MathJax components, including
the TeX and MathML preprocessors and input processors, the AMSmath,
AMSsymbols, noErrors, and noUndefined TeX extensions, the SVG output
processor definitions, and the MathMenu and MathZoom extensions. It
is equivalent to the following configuration:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/TeX&quot;</span><span class="p">,</span><span class="s2">&quot;input/MathML&quot;</span><span class="p">,</span><span class="s2">&quot;output/SVG&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;tex2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;mml2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">],</span>
<span class="nx">TeX</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;AMSmath.js&quot;</span><span class="p">,</span><span class="s2">&quot;AMSsymbols.js&quot;</span><span class="p">,</span><span class="s2">&quot;noErrors.js&quot;</span><span class="p">,</span><span class="s2">&quot;noUndefined.js&quot;</span><span class="p">]</span>
<span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>In addition, it loads the mml Element Jax, the TeX and MathML input
jax main code (not just the definition files), as well as the
<cite>toMathML</cite> extension, which is used by the Show Source option in the
MathJax contextual menu. The <tt class="docutils literal"><span class="pre">-full</span></tt> version also loads both the
SVG output jax main code, plus the SVG <cite>mtable</cite> extension, which
is normally loaded on demand.</p>
<p>See the <a class="reference internal" href="options/tex2jax.html#configure-tex2jax"><em>tex2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">tex2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/TeX.html#configure-tex"><em>TeX input jax configuration</em></a> section for options
that control the TeX input processor.
See the <a class="reference internal" href="options/mml2jax.html#configure-mml2jax"><em>mml2jax configuration</em></a> section for
other configuration options for the <tt class="docutils literal"><span class="pre">mml2jax</span></tt> preprocessor, and the
<a class="reference internal" href="options/MathML.html#configure-mathml"><em>MathML input jax configuration</em></a> section for
options that control the MathML input processor.
See <a class="reference internal" href="output.html#output-formats"><em>MathJax Output Formats</em></a> for more
information on the SVG output processor.</p>
</div>
<div class="section" id="the-accessible-configuration-file">
<h2>The <tt class="docutils literal"><span class="pre">Accessible</span></tt> configuration file<a class="headerlink" href="#the-accessible-configuration-file" title="Permalink to this headline"></a></h2>
<p>This configuration file is essentially the same as
<tt class="docutils literal"><span class="pre">TeX-AMS-MML_HTMLorMML</span></tt> except that it includes options that are
designed for assistive technology, particularly for those with visual
challenged. <em>This file is deprecated</em> since the controls that make
MathJax work with screen readers are now available in the MathJax
contextual menu, and so there is no need to set them in the
configuration file any longer. So you can use any of the other
pre-defined configurations and readers with special needs should be
able to change the MathJax settings themselves to be appropriate for
their software.</p>
<p>The Accessible configuration is equivalent to the following:</p>
<div class="highlight-javascript"><div class="highlight"><pre><span class="nx">MathJax</span><span class="p">.</span><span class="nx">Hub</span><span class="p">.</span><span class="nx">Config</span><span class="p">({</span>
<span class="nx">config</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;MMLorHTML.js&quot;</span><span class="p">],</span>
<span class="nx">jax</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;input/TeX&quot;</span><span class="p">,</span><span class="s2">&quot;input/MathML&quot;</span><span class="p">,</span><span class="s2">&quot;output/HTML-CSS&quot;</span><span class="p">,</span><span class="s2">&quot;output/NativeMML&quot;</span><span class="p">],</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;tex2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;mml2jax.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathMenu.js&quot;</span><span class="p">,</span><span class="s2">&quot;MathZoom.js&quot;</span><span class="p">],</span>
<span class="nx">TeX</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">extensions</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;AMSmath.js&quot;</span><span class="p">,</span><span class="s2">&quot;AMSsymbols.js&quot;</span><span class="p">,</span><span class="s2">&quot;noErrors.js&quot;</span><span class="p">,</span><span class="s2">&quot;noUndefined.js&quot;</span><span class="p">]</span>
<span class="p">},</span>
<span class="nx">menuSettings</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">zoom</span><span class="o">:</span> <span class="s2">&quot;Double-Click&quot;</span><span class="p">,</span>
<span class="nx">mpContext</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
<span class="nx">mpMouse</span><span class="o">:</span> <span class="kc">true</span>
<span class="p">},</span>
<span class="nx">errorSettings</span><span class="o">:</span> <span class="p">{</span> <span class="nx">message</span><span class="o">:</span> <span class="p">[</span><span class="s2">&quot;[Math Error]&quot;</span><span class="p">]</span> <span class="p">}</span>
<span class="p">});</span>
</pre></div>
</div>
<p>This turns off the MathJax contextual menu for IE when MathPlayer is
active, and passes mouse events on to MathPlayer to allow screen
readers full access to MathPlayer. It also sets the zoom trigger
to double-click, so that readers can see a larger version of the
mathematics but double-clicking on any equation.</p>
<p>In addition, it loads the mml Element Jax, the TeX and MathML input jax
main code (not just the definition files), as well as the <cite>toMathML</cite>
extension, which is used by the Show Source option in the MathJax
contextual menu. The <tt class="docutils literal"><span class="pre">-full</span></tt> version also loads both the HTML-CSS and
NativeMML output jax main code, plus the HTML-CSS <cite>mtable</cite> extension, which
is normally loaded on demand.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Common Configurations</a><ul>
<li><a class="reference internal" href="#the-tex-mml-am-htmlormml-configuration-file">The <tt class="docutils literal"><span class="pre">TeX-MML-AM_HTMLorMML</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-tex-ams-mml-htmlormml-configuration-file">The <tt class="docutils literal"><span class="pre">TeX-AMS-MML_HTMLorMML</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-tex-ams-html-configuration-file">The <tt class="docutils literal"><span class="pre">TeX-AMS_HTML</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-mml-htmlormml-configuration-file">The <tt class="docutils literal"><span class="pre">MML_HTMLorMML</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-am-htmlormml-configuration-file">The <tt class="docutils literal"><span class="pre">AM_HTMLorMML</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-tex-ams-mml-svg-configuration-file">The <tt class="docutils literal"><span class="pre">TeX-AMS-MML_SVG</span></tt> configuration file</a></li>
<li><a class="reference internal" href="#the-accessible-configuration-file">The <tt class="docutils literal"><span class="pre">Accessible</span></tt> configuration file</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="configuration.html"
title="previous chapter">Loading and Configuring MathJax</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="options/index.html"
title="next chapter">Configuration Objects</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="options/index.html" title="Configuration Objects"
>next</a> |</li>
<li class="right" >
<a href="configuration.html" title="Loading and Configuring MathJax"
>previous</a> |</li>
<li><a href="index.html">MathJax v2.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; Copyright 2012 Design Science.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More