354 lines
28 KiB
HTML
354 lines
28 KiB
HTML
|
|
<!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 — MathJax v1.1 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: '1.1',
|
|
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 v1.1 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 v1.1 documentation</a> »</li>
|
|
<li><a href="index.html" accesskey="U">The MathJax API</a> »</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’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">"bar"</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 "bar"</span>
|
|
<span class="nx">foo</span><span class="p">.</span><span class="nx">setX</span><span class="p">(</span><span class="s2">"foobar"</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 "foobar"</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> — object that defines the properties and methods</li>
|
|
<li><strong>static</strong> — 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> — object that defines the properties and methods</li>
|
|
<li><strong>static</strong> — 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("bar")</span></tt>, which calls the
|
|
<tt class="docutils literal"><span class="pre">MathJax.Object.Foo</span></tt> object’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">"bar"</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> — 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">"getX"</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">"bar"</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">"getX"</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">"x"</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">"bar"</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’ <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">"Class1: x and y = "</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">" and "</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">"Class2: "</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">"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">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">"Class4: "</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">"foo"</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">"bar"</span><span class="p">);</span> <span class="c1">// returns "Class2: Class1: x and y = foo and bar"</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">"bar"</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">"foo"</span><span class="p">);</span> <span class="c1">// returns "Class3: Class2: Class1: x and y = bar and foo"</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">"moo"</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">"cow"</span><span class="p">);</span> <span class="c1">// returns "Class4: Class1: x and y = moo and cow"</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">"Class1: x and y = "</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">" and "</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">"Class2: "</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's OK if a method doesn'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">"foo"</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">"bar"</span><span class="p">);</span> <span class="c1">// returns "Class2: Class1: x and y = foo and bar"</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 v1.1 documentation</a> »</li>
|
|
<li><a href="index.html" >The MathJax API</a> »</li>
|
|
</ul>
|
|
</div>
|
|
<div class="footer">
|
|
© Copyright 2011 Design Science.
|
|
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
|
|
</div>
|
|
|
|
</body>
|
|
</html> |