gollum 1.3.1 → 1.4.2

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

@@ -1,79 +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 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

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

@@ -1,196 +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:* 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

@@ -1,259 +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 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