gollum 1.1.1 → 1.2.0

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/CSS-styles.txt

@@ -0,0 +1,79 @@
+.. _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 attibute 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 .merror": {
+        "background-color": "#FFFF88",
+        color:   "#CC0000",
+        border:  "1px solid #CC0000",
+        padding: "1px 3px",
+        "font-family": "serif",
+        "font-style": "normal",
+        "font-size":  "90%"
+      },
+
+      ".MathJax_Preview": {color: "#888888"},
+
+    }
+
+This defines two CSS styles, one for the selector ``.MathJax
+.merror``, which specifies a background color, foreground color,
+border, and so on, and a second for ``.MathJax_Preview`` that sets its
+color.
+
+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.

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/HTML-snippets.txt

@@ -0,0 +1,83 @@
+.. _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
+configutation 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 elements that formt
+he 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>
+

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/api/ajax.txt

@@ -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/gollum/frontend/public/javascript/MathJax/docs/html/_sources/api/callback.txt

@@ -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