amiba 0.0.8 → 0.0.9

data/lib/amiba/frontend/public/javascript/MathJax/docs/rst/_static/mathjax_mathml.user.js

@@ -0,0 +1,22 @@
+// ==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.src = "http://www.yoursite.edu/MathJax/MathJax.js";  // put your URL here
+    var config = 'MathJax.Hub.Config({' +
+                   'extensions:["mml2jax.js"],' +
+                   'jax:["input/MathML","output/HTML-CSS"]' +
+                 '});' +
+	'MathJax.Hub.Startup.onload()';
+    if (window.opera) {script.innerHTML = config} else {script.text = config}
+    document.getElementsByTagName("head")[0].appendChild(script);
+    }
+}

data/lib/amiba/frontend/public/javascript/MathJax/docs/rst/_static/mathjax_wikipedia.user.js

@@ -0,0 +1,35 @@
+// ==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');
+  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);
+    }
+  }
+  //
+  //  Load MathJax and have it process the page
+  //
+  var script = document.createElement("script");
+  script.src = "http://www.yoursite.edu/MathJax/MathJax.js";  // put your URL here
+  var config = 'MathJax.Hub.Config({' +
+                 'config: ["MMLorHTML.js"],' +
+                 'extensions:["TeX/noErrors.js","TeX/noUndefined.js",' +
+                             '"TeX/AMSmath.js","TeX/AMSsymbols.js"],' +
+                 'jax:["input/TeX"]' +
+               '});' +
+               'MathJax.Hub.Startup.onload()';
+  if (window.opera) {script.innerHTML = config} else {script.text = config}
+  document.getElementsByTagName("head")[0].appendChild(script);
+}

data/lib/amiba/frontend/public/javascript/MathJax/docs/rst/api/ajax.rst

@@ -0,0 +1,196 @@
+.. _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:* 20 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.
+
+
+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 or 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 need 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:: 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

data/lib/amiba/frontend/public/javascript/MathJax/docs/rst/api/callback.rst

@@ -0,0 +1,259 @@
+.. _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 that 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
+
+	    ["length",[1,2,3,4]]
+
+        would call the `length` method on the array ``[1,2,3,4]`` when
+        the callback is called, returning ``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 exectued 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:: 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.  It `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:: 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