allow the notebook to run without MathJax

* add `--no-mathjax` flag for disabling mathjax in the notebook server
* A jQuery dialog with our 'no mathjax' message will appear if mathjax is unavailable, but the notebook will be fully functional after dismissal.
* Various calls to MathJax.Hub.typeset moved to Cell.typeset, which checks for MathJax existence and is a no-op without it.

closes  #1071

IPython/frontend/html/notebook/handlers.py

@@ -1,579 +1,581 b''
 """Tornado handlers for the notebook.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import logging
 import Cookie
 import uuid
 
 from tornado import web
 from tornado import websocket
 
 from zmq.eventloop import ioloop
 from zmq.utils import jsonapi
 
 from IPython.external.decorator import decorator
 from IPython.zmq.session import Session
 from IPython.lib.security import passwd_check
 
 try:
     from docutils.core import publish_string
 except ImportError:
     publish_string = None
 
 #-----------------------------------------------------------------------------
 # Monkeypatch for Tornado <= 2.1.1 - Remove when no longer necessary!
 #-----------------------------------------------------------------------------
 
 # Google Chrome, as of release 16, changed its websocket protocol number.  The
 # parts tornado cares about haven't really changed, so it's OK to continue
 # accepting Chrome connections, but as of Tornado 2.1.1 (the currently released
 # version as of Oct 30/2011) the version check fails, see the issue report:
 
 # https://github.com/facebook/tornado/issues/385
 
 # This issue has been fixed in Tornado post 2.1.1:
 
 # https://github.com/facebook/tornado/commit/84d7b458f956727c3b0d6710
 
 # Here we manually apply the same patch as above so that users of IPython can
 # continue to work with an officially released Tornado.  We make the
 # monkeypatch version check as narrow as possible to limit its effects; once
 # Tornado 2.1.1 is no longer found in the wild we'll delete this code.
 
 import tornado
 
 if tornado.version_info <= (2,1,1):
 
     def _execute(self, transforms, *args, **kwargs):
         from tornado.websocket import WebSocketProtocol8, WebSocketProtocol76
         
         self.open_args = args
         self.open_kwargs = kwargs
 
         # The difference between version 8 and 13 is that in 8 the
         # client sends a "Sec-Websocket-Origin" header and in 13 it's
         # simply "Origin".
         if self.request.headers.get("Sec-WebSocket-Version") in ("7", "8", "13"):
             self.ws_connection = WebSocketProtocol8(self)
             self.ws_connection.accept_connection()
             
         elif self.request.headers.get("Sec-WebSocket-Version"):
             self.stream.write(tornado.escape.utf8(
                 "HTTP/1.1 426 Upgrade Required\r\n"
                 "Sec-WebSocket-Version: 8\r\n\r\n"))
             self.stream.close()
             
         else:
             self.ws_connection = WebSocketProtocol76(self)
             self.ws_connection.accept_connection()
 
     websocket.WebSocketHandler._execute = _execute
     del _execute
     
 #-----------------------------------------------------------------------------
 # Decorator for disabling read-only handlers
 #-----------------------------------------------------------------------------
 
 @decorator
 def not_if_readonly(f, self, *args, **kwargs):
     if self.application.read_only:
         raise web.HTTPError(403, "Notebook server is read-only")
     else:
         return f(self, *args, **kwargs)
 
 @decorator
 def authenticate_unless_readonly(f, self, *args, **kwargs):
     """authenticate this page *unless* readonly view is active.
     
     In read-only mode, the notebook list and print view should
     be accessible without authentication.
     """
     
     @web.authenticated
     def auth_f(self, *args, **kwargs):
         return f(self, *args, **kwargs)
     if self.application.read_only:
         return f(self, *args, **kwargs)
     else:
         return auth_f(self, *args, **kwargs)
 
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 
 class RequestHandler(web.RequestHandler):
     """RequestHandler with default variable setting."""
 
     def render(*args, **kwargs):
         kwargs.setdefault('message', '')
         return web.RequestHandler.render(*args, **kwargs)
 
 class AuthenticatedHandler(RequestHandler):
     """A RequestHandler with an authenticated user."""
 
     def get_current_user(self):
         user_id = self.get_secure_cookie("username")
         # For now the user_id should not return empty, but it could eventually
         if user_id == '':
             user_id = 'anonymous'
         if user_id is None:
             # prevent extra Invalid cookie sig warnings:
             self.clear_cookie('username')
             if not self.application.password and not self.application.read_only:
                 user_id = 'anonymous'
         return user_id
     
     @property
     def read_only(self):
         if self.application.read_only:
             if self.application.password:
                 return self.get_current_user() is None
             else:
                 return True
         else:
             return False
     
     @property
     def ws_url(self):
         """websocket url matching the current request
         
         turns http[s]://host[:port] into
                 ws[s]://host[:port]
         """
         proto = self.request.protocol.replace('http', 'ws')
         return "%s://%s" % (proto, self.request.host)
 
 
 class ProjectDashboardHandler(AuthenticatedHandler):
 
     @authenticate_unless_readonly
     def get(self):
         nbm = self.application.notebook_manager
         project = nbm.notebook_dir
         self.render(
             'projectdashboard.html', project=project,
             base_project_url=u'/', base_kernel_url=u'/',
             read_only=self.read_only,
         )
 
 
 class LoginHandler(AuthenticatedHandler):
 
     def _render(self, message=None):
         self.render('login.html',
                 next=self.get_argument('next', default='/'),
                 read_only=self.read_only,
                 message=message
         )
 
     def get(self):
         if self.current_user:
             self.redirect(self.get_argument('next', default='/'))
         else:
             self._render()
 
     def post(self):
         pwd = self.get_argument('password', default=u'')
         if self.application.password:
             if passwd_check(self.application.password, pwd):
                 self.set_secure_cookie('username', str(uuid.uuid4()))
             else:
                 self._render(message={'error': 'Invalid password'})
                 return
 
         self.redirect(self.get_argument('next', default='/'))
 
 
 class LogoutHandler(AuthenticatedHandler):
 
     def get(self):
         self.clear_cookie('username')
         self.render('logout.html', message={'info': 'Successfully logged out.'})
 
 
 class NewHandler(AuthenticatedHandler):
 
     @web.authenticated
     def get(self):
         nbm = self.application.notebook_manager
         project = nbm.notebook_dir
         notebook_id = nbm.new_notebook()
         self.render(
             'notebook.html', project=project,
             notebook_id=notebook_id,
             base_project_url=u'/', base_kernel_url=u'/',
             kill_kernel=False,
             read_only=False,
+            enable_mathjax=self.application.ipython_app.enable_mathjax,
         )
 
 
 class NamedNotebookHandler(AuthenticatedHandler):
 
     @authenticate_unless_readonly
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         project = nbm.notebook_dir
         if not nbm.notebook_exists(notebook_id):
             raise web.HTTPError(404, u'Notebook does not exist: %s' % notebook_id)
         
         self.render(
             'notebook.html', project=project,
             notebook_id=notebook_id,
             base_project_url=u'/', base_kernel_url=u'/',
             kill_kernel=False,
             read_only=self.read_only,
+            enable_mathjax=self.application.ipython_app.enable_mathjax,
         )
 
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(AuthenticatedHandler):
 
     @web.authenticated
     def get(self):
         km = self.application.kernel_manager
         self.finish(jsonapi.dumps(km.kernel_ids))
 
     @web.authenticated
     def post(self):
         km = self.application.kernel_manager
         notebook_id = self.get_argument('notebook', default=None)
         kernel_id = km.start_kernel(notebook_id)
         data = {'ws_url':self.ws_url,'kernel_id':kernel_id}
         self.set_header('Location', '/'+kernel_id)
         self.finish(jsonapi.dumps(data))
 
 
 class KernelHandler(AuthenticatedHandler):
 
     SUPPORTED_METHODS = ('DELETE')
 
     @web.authenticated
     def delete(self, kernel_id):
         km = self.application.kernel_manager
         km.kill_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(AuthenticatedHandler):
 
     @web.authenticated
     def post(self, kernel_id, action):
         km = self.application.kernel_manager
         if action == 'interrupt':
             km.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             new_kernel_id = km.restart_kernel(kernel_id)
             data = {'ws_url':self.ws_url,'kernel_id':new_kernel_id}
             self.set_header('Location', '/'+new_kernel_id)
             self.write(jsonapi.dumps(data))
         self.finish()
 
 
 class ZMQStreamHandler(websocket.WebSocketHandler):
 
     def _reserialize_reply(self, msg_list):
         """Reserialize a reply message using JSON.
 
         This takes the msg list from the ZMQ socket, unserializes it using
         self.session and then serializes the result using JSON. This method
         should be used by self._on_zmq_reply to build messages that can
         be sent back to the browser.
         """
         idents, msg_list = self.session.feed_identities(msg_list)
         msg = self.session.unserialize(msg_list)
         try:
             msg['header'].pop('date')
         except KeyError:
             pass
         try:
             msg['parent_header'].pop('date')
         except KeyError:
             pass
         msg.pop('buffers')
         return jsonapi.dumps(msg)
 
     def _on_zmq_reply(self, msg_list):
         try:
             msg = self._reserialize_reply(msg_list)
         except:
             self.application.log.critical("Malformed message: %r" % msg_list)
         else:
             self.write_message(msg)
 
 
 class AuthenticatedZMQStreamHandler(ZMQStreamHandler):
 
     def open(self, kernel_id):
         self.kernel_id = kernel_id.decode('ascii')
         try:
             cfg = self.application.ipython_app.config
         except AttributeError:
             # protect from the case where this is run from something other than
             # the notebook app:
             cfg = None
         self.session = Session(config=cfg)
         self.save_on_message = self.on_message
         self.on_message = self.on_first_message
 
     def get_current_user(self):
         user_id = self.get_secure_cookie("username")
         if user_id == '' or (user_id is None and not self.application.password):
             user_id = 'anonymous'
         return user_id
 
     def _inject_cookie_message(self, msg):
         """Inject the first message, which is the document cookie,
         for authentication."""
         if isinstance(msg, unicode):
             # Cookie can't constructor doesn't accept unicode strings for some reason
             msg = msg.encode('utf8', 'replace')
         try:
             self.request._cookies = Cookie.SimpleCookie(msg)
         except:
             logging.warn("couldn't parse cookie string: %s",msg, exc_info=True)
 
     def on_first_message(self, msg):
         self._inject_cookie_message(msg)
         if self.get_current_user() is None:
             logging.warn("Couldn't authenticate WebSocket connection")
             raise web.HTTPError(403)
         self.on_message = self.save_on_message
 
 
 class IOPubHandler(AuthenticatedZMQStreamHandler):
 
     def initialize(self, *args, **kwargs):
         self._kernel_alive = True
         self._beating = False
         self.iopub_stream = None
         self.hb_stream = None
 
     def on_first_message(self, msg):
         try:
             super(IOPubHandler, self).on_first_message(msg)
         except web.HTTPError:
             self.close()
             return
         km = self.application.kernel_manager
         self.time_to_dead = km.time_to_dead
         kernel_id = self.kernel_id
         try:
             self.iopub_stream = km.create_iopub_stream(kernel_id)
             self.hb_stream = km.create_hb_stream(kernel_id)
         except web.HTTPError:
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             if not self.stream.closed():
                 self.stream.close()
             self.close()
         else:
             self.iopub_stream.on_recv(self._on_zmq_reply)
             self.start_hb(self.kernel_died)
 
     def on_message(self, msg):
         pass
 
     def on_close(self):
         # This method can be called twice, once by self.kernel_died and once
         # from the WebSocket close event. If the WebSocket connection is
         # closed before the ZMQ streams are setup, they could be None.
         self.stop_hb()
         if self.iopub_stream is not None and not self.iopub_stream.closed():
             self.iopub_stream.on_recv(None)
             self.iopub_stream.close()
         if self.hb_stream is not None and not self.hb_stream.closed():
             self.hb_stream.close()
 
     def start_hb(self, callback):
         """Start the heartbeating and call the callback if the kernel dies."""
         if not self._beating:
             self._kernel_alive = True
 
             def ping_or_dead():
                 if self._kernel_alive:
                     self._kernel_alive = False
                     self.hb_stream.send(b'ping')
                 else:
                     try:
                         callback()
                     except:
                         pass
                     finally:
                         self._hb_periodic_callback.stop()
 
             def beat_received(msg):
                 self._kernel_alive = True
 
             self.hb_stream.on_recv(beat_received)
             self._hb_periodic_callback = ioloop.PeriodicCallback(ping_or_dead, self.time_to_dead*1000)
             self._hb_periodic_callback.start()
             self._beating= True
 
     def stop_hb(self):
         """Stop the heartbeating and cancel all related callbacks."""
         if self._beating:
             self._hb_periodic_callback.stop()
             if not self.hb_stream.closed():
                 self.hb_stream.on_recv(None)
 
     def kernel_died(self):
         self.application.kernel_manager.delete_mapping_for_kernel(self.kernel_id)
         self.write_message(
             {'header': {'msg_type': 'status'},
              'parent_header': {},
              'content': {'execution_state':'dead'}
             }
         )
         self.on_close()
 
 
 class ShellHandler(AuthenticatedZMQStreamHandler):
 
     def initialize(self, *args, **kwargs):
         self.shell_stream = None
 
     def on_first_message(self, msg):
         try:
             super(ShellHandler, self).on_first_message(msg)
         except web.HTTPError:
             self.close()
             return
         km = self.application.kernel_manager
         self.max_msg_size = km.max_msg_size
         kernel_id = self.kernel_id
         try:
             self.shell_stream = km.create_shell_stream(kernel_id)
         except web.HTTPError:
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             if not self.stream.closed():
                 self.stream.close()
             self.close()
         else:
             self.shell_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
         if len(msg) < self.max_msg_size:
             msg = jsonapi.loads(msg)
             self.session.send(self.shell_stream, msg)
 
     def on_close(self):
         # Make sure the stream exists and is not already closed.
         if self.shell_stream is not None and not self.shell_stream.closed():
             self.shell_stream.close()
 
 
 #-----------------------------------------------------------------------------
 # Notebook web service handlers
 #-----------------------------------------------------------------------------
 
 class NotebookRootHandler(AuthenticatedHandler):
 
     @authenticate_unless_readonly
     def get(self):
         
         nbm = self.application.notebook_manager
         files = nbm.list_notebooks()
         self.finish(jsonapi.dumps(files))
 
     @web.authenticated
     def post(self):
         nbm = self.application.notebook_manager
         body = self.request.body.strip()
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         if body:
             notebook_id = nbm.save_new_notebook(body, name=name, format=format)
         else:
             notebook_id = nbm.new_notebook()
         self.set_header('Location', '/'+notebook_id)
         self.finish(jsonapi.dumps(notebook_id))
 
 
 class NotebookHandler(AuthenticatedHandler):
 
     SUPPORTED_METHODS = ('GET', 'PUT', 'DELETE')
 
     @authenticate_unless_readonly
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         last_mod, name, data = nbm.get_notebook(notebook_id, format)
         
         if format == u'json':
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename="%s.ipynb"' % name)
         elif format == u'py':
             self.set_header('Content-Type', 'application/x-python')
             self.set_header('Content-Disposition','attachment; filename="%s.py"' % name)
         self.set_header('Last-Modified', last_mod)
         self.finish(data)
 
     @web.authenticated
     def put(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         nbm.save_notebook(notebook_id, self.request.body, name=name, format=format)
         self.set_status(204)
         self.finish()
 
     @web.authenticated
     def delete(self, notebook_id):
         nbm = self.application.notebook_manager
         nbm.delete_notebook(notebook_id)
         self.set_status(204)
         self.finish()
 
 #-----------------------------------------------------------------------------
 # RST web service handlers
 #-----------------------------------------------------------------------------
 
 
 class RSTHandler(AuthenticatedHandler):
 
     @web.authenticated
     def post(self):
         if publish_string is None:
             raise web.HTTPError(503, u'docutils not available')
         body = self.request.body.strip()
         source = body
         # template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html')
         defaults = {'file_insertion_enabled': 0,
                     'raw_enabled': 0,
                     '_disable_config': 1,
                     'stylesheet_path': 0
                     # 'template': template_path
         }
         try:
             html = publish_string(source, writer_name='html',
                                   settings_overrides=defaults
             )
         except:
             raise web.HTTPError(400, u'Invalid RST')
         print html
         self.set_header('Content-Type', 'text/html')
         self.finish(html)
 
 

IPython/frontend/html/notebook/notebookapp.py

@@ -1,338 +1,360 b''
 """A tornado based IPython notebook server.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib
 import errno
 import logging
 import os
 import signal
 import socket
 import sys
 import threading
 import webbrowser
 
 # Third party
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 # FIXME: ioloop.install is new in pyzmq-2.1.7, so remove this conditional
 # when pyzmq dependency is updated beyond that.
 if hasattr(ioloop, 'install'):
     ioloop.install()
 else:
     import tornado.ioloop
     tornado.ioloop.IOLoop = ioloop.IOLoop
 
 from tornado import httpserver
 from tornado import web
 
 # Our own libraries
 from .kernelmanager import MappingKernelManager
 from .handlers import (LoginHandler, LogoutHandler,
     ProjectDashboardHandler, NewHandler, NamedNotebookHandler,
     MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler,
     ShellHandler, NotebookRootHandler, NotebookHandler, RSTHandler
 )
 from .notebookmanager import NotebookManager
 
 from IPython.config.application import catch_config_error
 from IPython.core.application import BaseIPythonApplication
 from IPython.core.profiledir import ProfileDir
 from IPython.zmq.session import Session, default_secure
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 from IPython.zmq.ipkernel import (
     flags as ipkernel_flags,
     aliases as ipkernel_aliases,
     IPKernelApp
 )
 from IPython.utils.traitlets import Dict, Unicode, Integer, List, Enum, Bool
 
 #-----------------------------------------------------------------------------
 # Module globals
 #-----------------------------------------------------------------------------
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 _notebook_id_regex = r"(?P<notebook_id>\w+-\w+-\w+-\w+-\w+)"
 
 LOCALHOST = '127.0.0.1'
 
 _examples = """
 ipython notebook                       # start the notebook
 ipython notebook --profile=sympy       # use the sympy profile
 ipython notebook --pylab=inline        # pylab in inline plotting mode
 ipython notebook --certfile=mycert.pem # use SSL/TLS certificate
 ipython notebook --port=5555 --ip=*    # Listen on port 5555, all interfaces
 """
 
 #-----------------------------------------------------------------------------
 # The Tornado web application
 #-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
     def __init__(self, ipython_app, kernel_manager, notebook_manager, log):
         handlers = [
             (r"/", ProjectDashboardHandler),
             (r"/login", LoginHandler),
             (r"/logout", LogoutHandler),
             (r"/new", NewHandler),
             (r"/%s" % _notebook_id_regex, NamedNotebookHandler),
             (r"/kernels", MainKernelHandler),
             (r"/kernels/%s" % _kernel_id_regex, KernelHandler),
             (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
             (r"/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler),
             (r"/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
             (r"/notebooks", NotebookRootHandler),
             (r"/notebooks/%s" % _notebook_id_regex, NotebookHandler),
             (r"/rstservice/render", RSTHandler)
         ]
         settings = dict(
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
             cookie_secret=os.urandom(1024),
             login_url="/login",
         )
         web.Application.__init__(self, handlers, **settings)
 
         self.kernel_manager = kernel_manager
         self.log = log
         self.notebook_manager = notebook_manager
         self.ipython_app = ipython_app
         self.read_only = self.ipython_app.read_only
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(ipkernel_flags)
 flags['no-browser']=(
     {'NotebookApp' : {'open_browser' : False}},
     "Don't open the notebook in a browser after startup."
 )
+flags['no-mathjax']=(
+    {'NotebookApp' : {'enable_mathjax' : False}},
+    """Disable MathJax
+    
+    MathJax is the javascript library IPython uses to render math/LaTeX. It is
+    very large, so you may want to disable it if you have a slow internet
+    connection, or for offline use of the notebook.
+    
+    When disabled, equations etc. will appear as their untransformed TeX source.
+    """
+)
 flags['read-only'] = (
     {'NotebookApp' : {'read_only' : True}},
     """Allow read-only access to notebooks.
     
     When using a password to protect the notebook server, this flag
     allows unauthenticated clients to view the notebook list, and
     individual notebooks, but not edit them, start kernels, or run
     code.
     
     If no password is set, the server will be entirely read-only.
     """
 )
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
-notebook_flags = ['no-browser', 'read-only']
+notebook_flags = ['no-browser', 'no-mathjax', 'read-only']
 
 aliases = dict(ipkernel_aliases)
 
 aliases.update({
     'ip': 'NotebookApp.ip',
     'port': 'NotebookApp.port',
     'keyfile': 'NotebookApp.keyfile',
     'certfile': 'NotebookApp.certfile',
     'notebook-dir': 'NotebookManager.notebook_dir',
 })
 
 # remove ipkernel flags that are singletons, and don't make sense in
 # multi-kernel evironment:
 aliases.pop('f', None)
 
 notebook_aliases = [u'port', u'ip', u'keyfile', u'certfile',
                     u'notebook-dir']
 
 #-----------------------------------------------------------------------------
 # NotebookApp
 #-----------------------------------------------------------------------------
 
 class NotebookApp(BaseIPythonApplication):
 
     name = 'ipython-notebook'
     default_config_file_name='ipython_notebook_config.py'
     
     description = """
         The IPython HTML Notebook.
         
         This launches a Tornado based HTML Notebook Server that serves up an
         HTML5/Javascript Notebook client.
     """
     examples = _examples
     
     classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session,
                MappingKernelManager, NotebookManager]
     flags = Dict(flags)
     aliases = Dict(aliases)
 
     kernel_argv = List(Unicode)
 
     log_level = Enum((0,10,20,30,40,50,'DEBUG','INFO','WARN','ERROR','CRITICAL'),
                     default_value=logging.INFO,
                     config=True,
                     help="Set the log level by value or name.")
 
     # Network related information.
 
     ip = Unicode(LOCALHOST, config=True,
         help="The IP address the notebook server will listen on."
     )
 
     def _ip_changed(self, name, old, new):
         if new == u'*': self.ip = u''
 
     port = Integer(8888, config=True,
         help="The port the notebook server will listen on."
     )
 
     certfile = Unicode(u'', config=True, 
         help="""The full path to an SSL/TLS certificate file."""
     )
     
     keyfile = Unicode(u'', config=True, 
         help="""The full path to a private key file for usage with SSL/TLS."""
     )
 
     password = Unicode(u'', config=True,
                       help="""Hashed password to use for web authentication.
 
                       To generate, type in a python/IPython shell:
 
                         from IPython.lib import passwd; passwd()
 
                       The string should be of the form type:salt:hashed-password.
                       """
     )
     
     open_browser = Bool(True, config=True,
                         help="Whether to open in a browser after starting.")
     
     read_only = Bool(False, config=True,
         help="Whether to prevent editing/execution of notebooks."
     )
 
+    enable_mathjax = Bool(True, config=True,
+        help="""Whether to enable MathJax for typesetting math/TeX
+
+        MathJax is the javascript library IPython uses to render math/LaTeX. It is
+        very large, so you may want to disable it if you have a slow internet
+        connection, or for offline use of the notebook.
+
+        When disabled, equations etc. will appear as their untransformed TeX source.
+        """
+    )
+
     def parse_command_line(self, argv=None):
         super(NotebookApp, self).parse_command_line(argv)
         if argv is None:
             argv = sys.argv[1:]
 
         self.kernel_argv = list(argv) # copy
         # Kernel should inherit default config file from frontend
         self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name)
         # Scrub frontend-specific flags
         for a in argv:
             if a.startswith('-') and a.lstrip('-') in notebook_flags:
                 self.kernel_argv.remove(a)
         swallow_next = False
         for a in argv:
             if swallow_next:
                 self.kernel_argv.remove(a)
                 swallow_next = False
                 continue
             if a.startswith('-'):
                 split = a.lstrip('-').split('=')
                 alias = split[0]
                 if alias in notebook_aliases:
                     self.kernel_argv.remove(a)
                     if len(split) == 1:
                         # alias passed with arg via space
                         swallow_next = True
 
     def init_configurables(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # force Session default to be secure
         default_secure(self.config)
         # Create a KernelManager and start a kernel.
         self.kernel_manager = MappingKernelManager(
             config=self.config, log=self.log, kernel_argv=self.kernel_argv,
             connection_dir = self.profile_dir.security_dir,
         )
         self.notebook_manager = NotebookManager(config=self.config, log=self.log)
         self.notebook_manager.list_notebooks()
 
     def init_logging(self):
         super(NotebookApp, self).init_logging()
         # This prevents double log messages because tornado use a root logger that
         # self.log is a child of. The logging module dipatches log messages to a log
         # and all of its ancenstors until propagate is set to False.
         self.log.propagate = False
 
     @catch_config_error
     def initialize(self, argv=None):
         super(NotebookApp, self).initialize(argv)
         self.init_configurables()
         self.web_app = NotebookWebApplication(
             self, self.kernel_manager, self.notebook_manager, self.log
         )
         if self.certfile:
             ssl_options = dict(certfile=self.certfile)
             if self.keyfile:
                 ssl_options['keyfile'] = self.keyfile
         else:
             ssl_options = None
         self.web_app.password = self.password
         self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options)
         if ssl_options is None and not self.ip:
             self.log.critical('WARNING: the notebook server is listening on all IP addresses '
                               'but not using any encryption or authentication. This is highly '
                               'insecure and not recommended.')
 
         # Try random ports centered around the default.
         from random import randint
         n = 50  # Max number of attempts, keep reasonably large.
         for port in range(self.port, self.port+5) + [self.port + randint(-2*n, 2*n) for i in range(n-5)]:
             try:
                 self.http_server.listen(port, self.ip)
             except socket.error, e:
                 if e.errno != errno.EADDRINUSE:
                     raise
                 self.log.info('The port %i is already in use, trying another random port.' % port)
             else:
                 self.port = port
                 break
 
     def start(self):
         ip = self.ip if self.ip else '[all ip addresses on your system]'
         proto = 'https' if self.certfile else 'http'
         self.log.info("The IPython Notebook is running at: %s://%s:%i" % (proto,
                                                                           ip,
                                                                           self.port))
         if self.open_browser:
             ip = self.ip or '127.0.0.1'
             b = lambda : webbrowser.open("%s://%s:%i" % (proto, ip, self.port),
                                          new=2)
             threading.Thread(target=b).start()
 
         ioloop.IOLoop.instance().start()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def launch_new_instance():
     app = NotebookApp()
     app.initialize()
     app.start()
 

IPython/frontend/html/notebook/static/css/notebook.css

@@ -1,436 +1,448 b''
 /**
  * Primary styles
  *
  * Author: IPython Development Team
  */
 
 
 body {
     background-color: white;
     /* This makes sure that the body covers the entire window and needs to
        be in a different element than the display: box in wrapper below */
     position: absolute;
     left: 0px;
     right: 0px;
     top: 0px;
     bottom: 0px;
     overflow: hidden;
 }
 
 span#save_widget {
     position: static;
     left: 0px;
     padding: 5px 0px;
     margin: 0px 0px 0px 0px;
 }
 
 span#quick_help_area {
     position: static;
     padding: 5px 0px;
     margin: 0px 0px 0px 0px;
 }
 
 input#notebook_name {
     height: 1em;
     line-height: 1em;
     padding: 5px;
 }
 
 span#kernel_status {
     position: absolute;
     padding: 8px 5px 5px 5px;
     right: 10px;
     font-weight: bold;
 }
 
 
 .status_idle {
     color: gray;
     visibility: hidden;
 }
 
 .status_busy {
     color: red;
 }
 
 .status_restarting {
     color: black;
 }
 
 div#left_panel {
     overflow-y: auto;
     top: 0px;
     left: 0px;
     margin: 0px;
     padding: 0px;
     position: absolute;
 }
 
 div.section_header {
     padding: 5px;
 }
 
 div.section_header h3 {
     display: inline;
 }
 
 div.section_content {
     padding: 5px;
 }
 
 span.section_row_buttons button {
     width: 70px;
 }
 
 span.section_row_buttons a {
     width: 70px;
 }
 
 .section_row {
     margin: 5px 0px;
 }
 
 .section_row_buttons {
     float: right;
 }
 
 #kernel_persist {
     float: right;
 }
 
 .help_string {
     float: right;
     width: 170px;
     padding: 0px 5px;
     text-align: left;
     font-size: 85%;
 }
 
 .help_string_label {
     float: right;
     font-size: 85%;
 }
 
 #autoindent_span {
     float: right;
 }
 
 #timebeforetooltip_span {
     float: right;
 }
 
 #tooltipontab_span {
     float: right;
 }
 
 #smartcompleter_span {
     float: right;
 }
 
 .checkbox_label {
     font-size: 85%;
     float: right;
     padding: 0.3em;
 }
 
 .section_row_header {
     float: left;
     font-size: 85%;
     padding: 0.4em 0em;
     font-weight: bold;
 }
 
 span.button_label {
     padding: 0.2em 1em;
     font-size: 77%;
     float: right;
 }
 
 /* This is needed because FF was adding a 2px margin top and bottom. */
 .section_row .ui-button {
     margin-top: 0px;
     margin-bottom: 0px;
 }
 
 #download_format {
     float: right;
     font-size: 85%;
     width: 62px;
     margin: 1px 5px;
 }
 
 div#left_panel_splitter {
     width: 8px;
     top: 0px;
     left: 202px;
     margin: 0px;
     padding: 0px;
     position: absolute;
 }
 
 div#notebook_panel {
 /*    The L margin will be set in the Javascript code*/
     margin: 0px 0px 0px 0px;
     padding: 0px;
 }
 
 div#notebook {
     overflow-y: scroll;
     overflow-x: auto;
     width: 100%;
     /* This spaces the cell away from the edge of the notebook area */
     padding: 5px 5px 15px 5px;
     margin: 0px
     background-color: white;
 }
 
 div#pager_splitter {
     height: 8px;
 }
 
 div#pager {
     padding: 15px;
     overflow: auto;
 }
 
 div.cell {
     width: 100%;
     padding: 5px 5px 5px 0px;
     /* This acts as a spacer between cells, that is outside the border */
     margin: 2px 0px 2px 0px;
 }
 
 div.code_cell {
     background-color: white;
 }
 /* any special styling for code cells that are currently running goes here */
 div.code_cell.running {
 }
 
 div.prompt {
     /* This needs to be wide enough for 3 digit prompt numbers: In[100]: */
     width: 11ex;
     /* This 0.4em is tuned to match the padding on the CodeMirror editor. */
     padding: 0.4em;
     margin: 0px;
     font-family: monospace;
     text-align:right;
 }
 
 div.input {
     page-break-inside: avoid;
 }
 
 /* input_area and input_prompt must match in top border and margin for alignment */
 div.input_area {
     color: black;
     border: 1px solid #ddd;
     border-radius: 3px;
     background: #f7f7f7;
 }
 
 div.input_prompt {
     color: navy;
     border-top: 1px solid transparent;
 }
 
 div.output {
     /* This is a spacer between the input and output of each cell */
     margin-top: 5px;
 }
 
 div.output_prompt {
     color: darkred;
 }
 
 /* This class is the outer container of all output sections. */
 div.output_area {
     padding: 0px;
     page-break-inside: avoid;
 }
 
 /* This class is for the output subarea inside the output_area and after
    the prompt div. */
 div.output_subarea {
     padding: 0.4em 6.1em 0.4em 0.4em;
 }
 
 /* The rest of the output_* classes are for special styling of the different
    output types */
 
 /* all text output has this class: */
 div.output_text {
     text-align: left;
     color: black;
     font-family: monospace;
 }
 
 /* stdout/stderr are 'text' as well as 'stream', but pyout/pyerr are *not* streams */
 div.output_stream {
     padding-top: 0.0em;
     padding-bottom: 0.0em;
 }
 div.output_stdout {
 }
 div.output_stderr {
     background: #fdd; /* very light red background for stderr */
 }
 
 div.output_latex {
     text-align: left;
     color: black;
 }
 
 div.output_html {
 }
 
 div.output_png {
 }
 
 div.output_jpeg {
 }
 
 div.text_cell {
     background-color: white;
 }
 
 div.text_cell_input {
     color: black;
 }
 
 div.text_cell_render {
     font-family: "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     outline: none;
     resize: none;
     width:  inherit;
     border-style: none;
     padding: 5px;
     color: black;
 }
 
 .CodeMirror {
     line-height: 1.231;  /* Changed from 1em to our global default */
 }
 
 .CodeMirror-scroll {
     height: auto;     /* Changed to auto to autogrow */
     /*  The CodeMirror docs are a bit fuzzy on if overflow-y should be hidden or visible.*/
     /*  We have found that if it is visible, vertical scrollbars appear with font size changes.*/
     overflow-y: hidden;
     overflow-x: auto; /* Changed from auto to remove scrollbar */
 }
 
 /* CSS font colors for translated ANSI colors. */
 
 
 .ansiblack {color: black;}
 .ansired {color: darkred;}
 .ansigreen {color: darkgreen;}
 .ansiyellow {color: brown;}
 .ansiblue {color: darkblue;}
 .ansipurple {color: darkviolet;}
 .ansicyan {color: steelblue;}
 .ansigrey {color: grey;}
 .ansibold {font-weight: bold;}
 
 .completions , .tooltip{
     position: absolute;
     z-index: 10;
     overflow: auto;
     border: 1px solid black;
 }
 
 .completions select {
     background: white;
     outline: none;
     border: none;
     padding: 0px;
     margin: 0px;
     font-family: monospace;
 }
 
 @-moz-keyframes fadeIn {
     from {opacity:0;}
     to {opacity:1;}
 }
 
 @-webkit-keyframes fadeIn {
     from {opacity:0;}
     to {opacity:1;}
 }
 
 @keyframes fadeIn {
     from {opacity:0;}
     to {opacity:1;}
 }
 
 /*"close" "expand" and "Open in pager button" of
 /* the tooltip*/
 .tooltip a{
     float:right;
 }
 
 /*properties of tooltip after "expand"*/
 .bigtooltip{
     height:30%;
 }
 
 /*properties of tooltip before "expand"*/
 .smalltooltip{
     text-overflow: ellipsis;
     overflow: hidden;
     height:15%;
 }
 
 .tooltip{
     /*transition when "expand"ing tooltip */
     -webkit-transition-property: height;
     -webkit-transition-duration: 1s;
     -moz-transition-property: height;
     -moz-transition-duration: 1s;
     transition-property: height;
     transition-duration: 1s;
     max-width:700px;
     border-radius: 0px 10px 10px 10px;
     box-shadow: 3px 3px 5px #999;
     /*fade-in animation when inserted*/
     -webkit-animation: fadeIn 200ms;
     -moz-animation: fadeIn 200ms;
     animation: fadeIn 200ms;
     vertical-align: middle;
     background: #FDFDD8;
     outline: none;
     padding: 3px;
     margin: 0px;
     font-family: monospace;
     min-height:50px;
 }
 
 .completions p{
     background: #DDF;
     /*outline: none;
     padding: 0px;*/
     border-bottom: black solid 1px;
     padding: 1px;
     font-family: monospace;
 }
 
+pre.dialog {
+    background-color: #f7f7f7;
+    border: 1px solid #ddd;
+    border-radius: 3px;
+    padding: 0.4em;
+    padding-left: 2em;
+}
+
+p.dialog{
+    padding : 0.2em;
+}
+
 @media print {
     body { overflow: visible !important; }
     .ui-widget-content { border: 0px; }
 }
 
 .shortcut_key {
     display: inline-block;
     width: 13ex;
     text-align: right;
     font-family: monospace;
 }
 
 .shortcut_descr {
 }
 
 /* Word-wrap output correctly.  This is the CSS3 spelling, though Firefox seems
    to not honor it correctly.  Webkit browsers (Chrome, rekonq, Safari) do.
  */
 pre, code, kbd, samp { white-space: pre-wrap; }

IPython/frontend/html/notebook/static/js/cell.js

@@ -1,96 +1,103 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Cell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Cell = function (notebook) {
         this.notebook = notebook;
         this.read_only = false;
         if (notebook){
             this.read_only = notebook.read_only;
         }
         this.selected = false;
         this.element = null;
         this.create_element();
         if (this.element !== null) {
             this.set_autoindent(true);
             this.element.data("cell", this);
             this.bind_events();
         }
         this.cell_id = utils.uuid();
     };
 
 
     Cell.prototype.select = function () {
         this.element.addClass('ui-widget-content ui-corner-all');
         this.selected = true;
     };
 
 
     Cell.prototype.unselect = function () {
         this.element.removeClass('ui-widget-content ui-corner-all');
         this.selected = false;
     };
 
 
     Cell.prototype.bind_events = function () {
         var that = this;
         var nb = that.notebook;
         that.element.click(function (event) {
             if (that.selected === false) {
                 nb.select(nb.find_cell_index(that));
             }
         });
         that.element.focusin(function (event) {
             if (that.selected === false) {
                 nb.select(nb.find_cell_index(that));
             }
         });
     };
 
     Cell.prototype.grow = function(element) {
         // Grow the cell by hand. This is used upon reloading from JSON, when the
         // autogrow handler is not called.
         var dom = element.get(0);
         var lines_count = 0;
         // modified split rule from
         // http://stackoverflow.com/questions/2035910/how-to-get-the-number-of-lines-in-a-textarea/2036424#2036424
         var lines = dom.value.split(/\r|\r\n|\n/);
         lines_count = lines.length;
         if (lines_count >= 1) {
             dom.rows = lines_count;
         } else {
             dom.rows = 1;
         }
     };
 
 
     Cell.prototype.set_autoindent = function (state) {
         if (state) {
             this.code_mirror.setOption('tabMode', 'indent');
             this.code_mirror.setOption('enterMode', 'indent');
         } else {
             this.code_mirror.setOption('tabMode', 'shift');
             this.code_mirror.setOption('enterMode', 'flat');
         }
     };
 
     // Subclasses must implement create_element.
     Cell.prototype.create_element = function () {};
 
+    // typeset with MathJax if MathJax is available
+    Cell.prototype.typeset = function () {
+        if (window.MathJax){
+            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+        }
+    };
+
     IPython.Cell = Cell;
 
     return IPython;
 
 }(IPython));
 

IPython/frontend/html/notebook/static/js/codecell.js

@@ -1,795 +1,795 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // CodeCell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var CodeCell = function (notebook) {
         this.code_mirror = null;
         this.input_prompt_number = ' ';
         this.is_completing = false;
         this.completion_cursor = null;
         this.outputs = [];
         this.collapsed = false;
         IPython.Cell.apply(this, arguments);
     };
 
 
     CodeCell.prototype = new IPython.Cell();
 
 
     CodeCell.prototype.create_element = function () {
         var cell =  $('<div></div>').addClass('cell border-box-sizing code_cell vbox');
         cell.attr('tabindex','2');
         var input = $('<div></div>').addClass('input hbox');
         input.append($('<div/>').addClass('prompt input_prompt'));
         var input_area = $('<div/>').addClass('input_area box-flex1');
         this.code_mirror = CodeMirror(input_area.get(0), {
             indentUnit : 4,
             mode: 'python',
             theme: 'ipython',
             readOnly: this.read_only,
             onKeyEvent: $.proxy(this.handle_codemirror_keyevent,this)
         });
         input.append(input_area);
         var output = $('<div></div>').addClass('output vbox');
         cell.append(input).append(output);
         this.element = cell;
         this.collapse();
     };
 
     //TODO, try to diminish the number of parameters.
     CodeCell.prototype.request_tooltip_after_time = function (pre_cursor,time,that){
         if (pre_cursor === "" || pre_cursor === "(" ) {
             // don't do anything if line beggin with '(' or is empty
         } else {
             // Will set a timer to request tooltip in `time`
             that.tooltip_timeout = setTimeout(function(){
                     IPython.notebook.request_tool_tip(that, pre_cursor)
                 },time);
         }
     };
 
     CodeCell.prototype.handle_codemirror_keyevent = function (editor, event) {
         // This method gets called in CodeMirror's onKeyDown/onKeyPress
         // handlers and is used to provide custom key handling. Its return
         // value is used to determine if CodeMirror should ignore the event:
         // true = ignore, false = don't ignore.
 
         // note that we are comparing and setting the time to wait at each key press.
         // a better wqy might be to generate a new function on each time change and
         // assign it to CodeCell.prototype.request_tooltip_after_time
         tooltip_wait_time = this.notebook.time_before_tooltip;
         tooltip_on_tab    = this.notebook.tooltip_on_tab;
         var that = this;
         // whatever key is pressed, first, cancel the tooltip request before
         // they are sent, and remove tooltip if any
         if(event.type === 'keydown' ){
             CodeCell.prototype.remove_and_cancel_tooltip(that.tooltip_timeout);
             that.tooltip_timeout=null;
         }
 
         if (event.keyCode === 13 && (event.shiftKey || event.ctrlKey)) {
             // Always ignore shift-enter in CodeMirror as we handle it.
             return true;
         }else if (event.which === 40 && event.type === 'keypress' && tooltip_wait_time >= 0) {
             // triger aon keypress (!) otherwise inconsistent event.which depending on plateform
             // browser and keyboard layout !
             // Pressing '(' , request tooltip, don't forget to reappend it
             var cursor = editor.getCursor();
             var pre_cursor = editor.getRange({line:cursor.line,ch:0},cursor).trim()+'(';
             CodeCell.prototype.request_tooltip_after_time(pre_cursor,tooltip_wait_time,that);
         } else if (event.keyCode === 9 && event.type == 'keydown') {
             // Tab completion.
             var cur = editor.getCursor();
             //Do not trim here because of tooltip
             var pre_cursor = editor.getRange({line:cur.line,ch:0},cur);
             if (pre_cursor.trim() === "") {
                 // Don't autocomplete if the part of the line before the cursor
                 // is empty.  In this case, let CodeMirror handle indentation.
                 return false;
             } else if ((pre_cursor.substr(-1) === "("|| pre_cursor.substr(-1) === " ") && tooltip_on_tab ) {
                 CodeCell.prototype.request_tooltip_after_time(pre_cursor,0,that);
             } else {
                 pre_cursor.trim();
                 // Autocomplete the current line.
                 event.stop();
                 var line = editor.getLine(cur.line);
                 this.is_completing = true;
                 this.completion_cursor = cur;
                 IPython.notebook.complete_cell(this, line, cur.ch);
                 return true;
             }
         } else if (event.keyCode === 8 && event.type == 'keydown') {
             // If backspace and the line ends with 4 spaces, remove them.
             var cur = editor.getCursor();
             var line = editor.getLine(cur.line);
             var ending = line.slice(-4);
             if (ending === '    ') {
                 editor.replaceRange('',
                     {line: cur.line, ch: cur.ch-4},
                     {line: cur.line, ch: cur.ch}
                 );
                 event.stop();
                 return true;
             } else {
                 return false;
             }
         } else if (event.keyCode === 76 && event.ctrlKey && event.shiftKey
                    && event.type == 'keydown') {
             // toggle line numbers with Ctrl-Shift-L
             this.toggle_line_numbers();
         }
         else {
             // keypress/keyup also trigger on TAB press, and we don't want to
             // use those to disable tab completion.
             if (this.is_completing && event.keyCode !== 9) {
                 var ed_cur = editor.getCursor();
                 var cc_cur = this.completion_cursor;
                 if (ed_cur.line !== cc_cur.line || ed_cur.ch !== cc_cur.ch) {
                     this.is_completing = false;
                     this.completion_cursor = null;
                 }
             }
             return false;
         };
         return false;
     };
 
     CodeCell.prototype.remove_and_cancel_tooltip = function(timeout)
     {
         // note that we don't handle closing directly inside the calltip
         // as in the completer, because it is not focusable, so won't
         // get the event.
         if(timeout != null)
         { clearTimeout(timeout);}
         $('#tooltip').remove();
     }
 
     CodeCell.prototype.finish_tooltip = function (reply) {
         defstring=reply.definition;
         docstring=reply.docstring;
         if(docstring == null){docstring="<empty docstring>"};
         name=reply.name;
 
         var that = this;
         var tooltip = $('<div/>').attr('id', 'tooltip').addClass('tooltip');
         // remove to have the tooltip not Limited in X and Y
         tooltip.addClass('smalltooltip');
         var pre=$('<pre/>').html(utils.fixConsole(docstring));
         var expandlink=$('<a/>').attr('href',"#");
             expandlink.addClass("ui-corner-all"); //rounded corner
             expandlink.attr('role',"button");
             //expandlink.addClass('ui-button');
             //expandlink.addClass('ui-state-default');
         var expandspan=$('<span/>').text('Expand');
             expandspan.addClass('ui-icon');
             expandspan.addClass('ui-icon-plus');
         expandlink.append(expandspan);
         expandlink.attr('id','expanbutton');
         expandlink.click(function(){
             tooltip.removeClass('smalltooltip');
             tooltip.addClass('bigtooltip');
             $('#expanbutton').remove();
             setTimeout(function(){that.code_mirror.focus();}, 50);
         });
         var morelink=$('<a/>').attr('href',"#");
             morelink.attr('role',"button");
             morelink.addClass('ui-button');
             //morelink.addClass("ui-corner-all"); //rounded corner
             //morelink.addClass('ui-state-default');
         var morespan=$('<span/>').text('Open in Pager');
             morespan.addClass('ui-icon');
             morespan.addClass('ui-icon-arrowstop-l-n');
         morelink.append(morespan);
         morelink.click(function(){
             var msg_id = IPython.notebook.kernel.execute(name+"?");
             IPython.notebook.msg_cell_map[msg_id] = IPython.notebook.selected_cell().cell_id;
             CodeCell.prototype.remove_and_cancell_tooltip(that.tooltip_timeout);
             setTimeout(function(){that.code_mirror.focus();}, 50);
         });
 
         var closelink=$('<a/>').attr('href',"#");
             closelink.attr('role',"button");
             closelink.addClass('ui-button');
             //closelink.addClass("ui-corner-all"); //rounded corner
             //closelink.adClass('ui-state-default'); // grey background and blue cross
         var closespan=$('<span/>').text('Close');
             closespan.addClass('ui-icon');
             closespan.addClass('ui-icon-close');
         closelink.append(closespan);
         closelink.click(function(){
             CodeCell.prototype.remove_and_cancell_tooltip(that.tooltip_timeout);
             setTimeout(function(){that.code_mirror.focus();}, 50);
             });
         //construct the tooltip
         tooltip.append(closelink);
         tooltip.append(expandlink);
         tooltip.append(morelink);
         if(defstring){
             defstring_html= $('<pre/>').html(utils.fixConsole(defstring));
             tooltip.append(defstring_html);
         }
         tooltip.append(pre);
         var pos = this.code_mirror.cursorCoords();
         tooltip.css('left',pos.x+'px');
         tooltip.css('top',pos.yBot+'px');
         $('body').append(tooltip);
 
         // issues with cross-closing if multiple tooltip in less than 5sec
         // keep it comented for now
         // setTimeout(CodeCell.prototype.remove_and_cancell_tooltip, 5000);
     };
 
     // As you type completer
     CodeCell.prototype.finish_completing = function (matched_text, matches) {
         //return if not completing or nothing to complete
         if (!this.is_completing || matches.length === 0) {return;}
 
         // for later readability
         var key = { tab:9,
                     esc:27,
                     backspace:8,
                     space:13,
                     shift:16,
                     enter:32,
                     // _ is 189
                     isCompSymbol : function (code)
                         {return ((code>64 && code <=122)|| code == 189)}
                     }
 
         // smart completion, sort kwarg ending with '='
         var newm = new Array();
         if(this.notebook.smart_completer)
         {
             kwargs = new Array();
             other = new Array();
             for(var i=0;i<matches.length; ++i){
                 if(matches[i].substr(-1) === '='){
                     kwargs.push(matches[i]);
                 }else{other.push(matches[i]);}
             }
             newm = kwargs.concat(other);
             matches=newm;
         }
         // end sort kwargs
 
         // give common prefix of a array of string
         function sharedStart(A){
             if(A.length > 1 ){
                 var tem1, tem2, s, A= A.slice(0).sort();
                 tem1= A[0];
                 s= tem1.length;
                 tem2= A.pop();
                 while(s && tem2.indexOf(tem1)== -1){
                     tem1= tem1.substring(0, --s);
                 }
                 return tem1;
             }
             return "";
         }
 
 
         //try to check if the user is typing tab at least twice after a word
         // and completion is "done"
         fallback_on_tooltip_after=2
         if(matches.length==1 && matched_text === matches[0])
         {
             if(this.npressed >fallback_on_tooltip_after  && this.prevmatch==matched_text)
             {
                 console.log('Ok, you really want to complete after pressing tab '+this.npressed+' times !');
                 console.log('You should understand that there is no (more) completion for that !');
                 console.log("I'll show you the tooltip, will you stop bothering me ?");
                 this.request_tooltip_after_time(matched_text+'(',0,this);
                 return;
             }
             this.prevmatch=matched_text
             this.npressed=this.npressed+1;
         }
         else
         {
             this.prevmatch="";
             this.npressed=0;
         }
         // end fallback on tooltip
         //==================================
         // Real completion logic start here
         var that = this;
         var cur = this.completion_cursor;
         var done = false;
 
         // call to dismmiss the completer
         var close = function () {
             if (done) return;
             done = true;
             if (complete!=undefined)
             {complete.remove();}
             that.is_completing = false;
             that.completion_cursor = null;
         };
 
         // insert the given text and exit the completer
         var insert = function (selected_text, event) {
             that.code_mirror.replaceRange(
                 selected_text,
                 {line: cur.line, ch: (cur.ch-matched_text.length)},
                 {line: cur.line, ch: cur.ch}
             );
             if(event != null){
                 event.stopPropagation();
                 event.preventDefault();
             }
             close();
             setTimeout(function(){that.code_mirror.focus();}, 50);
         };
 
         // insert the curent highlited selection and exit
         var pick = function () {
             insert(select.val()[0],null);
         };
 
 
         // Define function to clear the completer, refill it with the new
         // matches, update the pseuso typing field. autopick insert match if
         // only one left, in no matches (anymore) dismiss itself by pasting
         // what the user have typed until then
         var complete_with = function(matches,typed_text,autopick,event)
         {
             // If autopick an only one match, past.
             // Used to 'pick' when pressing tab
             if (matches.length < 1) {
                 insert(typed_text,event);
                 if(event !=null){
                 event.stopPropagation();
                 event.preventDefault();
                 }
             } else if (autopick && matches.length==1) {
                 insert(matches[0],event);
                 if(event !=null){
                 event.stopPropagation();
                 event.preventDefault();
                 }
             }
             //clear the previous completion if any
             complete.children().children().remove();
             $('#asyoutype').text(typed_text);
             select=$('#asyoutypeselect');
             for (var i=0; i<matches.length; ++i) {
                     select.append($('<option/>').html(matches[i]));
             }
             select.children().first().attr('selected','true');
         }
 
         // create html for completer
         var complete = $('<div/>').addClass('completions');
             complete.attr('id','complete');
         complete.append($('<p/>').attr('id', 'asyoutype').html(matched_text));//pseudo input field
 
         var select = $('<select/>').attr('multiple','true');
             select.attr('id', 'asyoutypeselect')
             select.attr('size',Math.min(10,matches.length));
         var pos = this.code_mirror.cursorCoords();
 
         // TODO: I propose to remove enough horizontal pixel
         // to align the text later
         complete.css('left',pos.x+'px');
         complete.css('top',pos.yBot+'px');
         complete.append(select);
 
         $('body').append(complete);
 
         // So a first actual completion.  see if all the completion start wit
         // the same letter and complete if necessary
         fastForward = sharedStart(matches)
         typed_characters= fastForward.substr(matched_text.length);
         complete_with(matches,matched_text+typed_characters,true,null);
         filterd=matches;
         // Give focus to select, and make it filter the match as the user type
         // by filtering the previous matches. Called by .keypress and .keydown
         var downandpress = function (event,press_or_down) {
             var code = event.which;
             var autopick = false; // auto 'pick' if only one match
             if (press_or_down === 0){
                 press=true; down=false; //Are we called from keypress or keydown
             } else if (press_or_down == 1){
                 press=false; down=true;
             }
             if (code === key.shift) {
                 // nothing on Shift
                 return;
             }
             if (code === key.space || code === key.enter) {
                 // Pressing SPACE or ENTER will cause a pick
                 event.stopPropagation();
                 event.preventDefault();
                 pick();
             } else if (code === 38 || code === 40) {
                 // We don't want the document keydown handler to handle UP/DOWN,
                 // but we want the default action.
                 event.stopPropagation();
             //} else if ( key.isCompSymbol(code)|| (code==key.backspace)||(code==key.tab && down)){
             } else if ( (code==key.backspace)||(code==key.tab && down) || press || key.isCompSymbol(code)){
                 if( key.isCompSymbol(code) && press)
                 {
                     var newchar = String.fromCharCode(code);
                     typed_characters=typed_characters+newchar;
                 } else if (code == key.tab) {
                     fastForward = sharedStart(filterd)
                     ffsub = fastForward.substr(matched_text.length+typed_characters.length);
                     typed_characters=typed_characters+ffsub;
                     autopick=true;
                     event.stopPropagation();
                     event.preventDefault();
                 } else if (code == key.backspace && down) {
                     // cancel if user have erase everything, otherwise decrease
                     // what we filter with
                     if (typed_characters.length <= 0)
                     {
                         insert(matched_text,event)
                     }
                     typed_characters=typed_characters.substr(0,typed_characters.length-1);
                 }else{return}
                 re = new RegExp("^"+"\%?"+matched_text+typed_characters,"");
                 filterd = matches.filter(function(x){return re.test(x)});
                 complete_with(filterd,matched_text+typed_characters,autopick,event);
             } else if(down){ // abort only on .keydown
                 // abort with what the user have pressed until now
                 console.log('aborting with keycode : '+code+' is down :'+down);
                 insert(matched_text+typed_characters,event);
             }
         }
         select.keydown(function (event) {
             downandpress(event,1)
         });
         select.keypress(function (event) {
             downandpress(event,0)
         });
         // Double click also causes a pick.
         // and bind the last actions.
         select.dblclick(pick);
         select.blur(close);
         select.focus();
     };
 
     CodeCell.prototype.toggle_line_numbers = function () {
         if (this.code_mirror.getOption('lineNumbers') == false) {
             this.code_mirror.setOption('lineNumbers', true);
         } else {
             this.code_mirror.setOption('lineNumbers', false);
         }
         this.code_mirror.refresh();
     };
 
     CodeCell.prototype.select = function () {
         IPython.Cell.prototype.select.apply(this);
         // Todo: this dance is needed because as of CodeMirror 2.12, focus is
         // not causing the cursor to blink if the editor is empty initially.
         // While this seems to fix the issue, this should be fixed
         // in CodeMirror proper.
         var s = this.code_mirror.getValue();
         this.code_mirror.focus();
         if (s === '') this.code_mirror.setValue('');
     };
 
 
     CodeCell.prototype.select_all = function () {
         var start = {line: 0, ch: 0};
         var nlines = this.code_mirror.lineCount();
         var last_line = this.code_mirror.getLine(nlines-1);
         var end = {line: nlines-1, ch: last_line.length};
         this.code_mirror.setSelection(start, end);
     };
 
 
     CodeCell.prototype.append_output = function (json) {
         this.expand();
         if (json.output_type === 'pyout') {
             this.append_pyout(json);
         } else if (json.output_type === 'pyerr') {
             this.append_pyerr(json);
         } else if (json.output_type === 'display_data') {
             this.append_display_data(json);
         } else if (json.output_type === 'stream') {
             this.append_stream(json);
         };
         this.outputs.push(json);
     };
 
 
     CodeCell.prototype.create_output_area = function () {
         var oa = $("<div/>").addClass("hbox output_area");
         oa.append($('<div/>').addClass('prompt'));
         return oa;
     };
 
 
     CodeCell.prototype.append_pyout = function (json) {
         n = json.prompt_number || ' ';
         var toinsert = this.create_output_area();
         toinsert.find('div.prompt').addClass('output_prompt').html('Out[' + n + ']:');
         this.append_mime_type(json, toinsert);
         this.element.find('div.output').append(toinsert);
         // If we just output latex, typeset it.
         if ((json.latex !== undefined) || (json.html !== undefined)) {
-            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+            this.typeset();
         };
     };
 
 
     CodeCell.prototype.append_pyerr = function (json) {
         var tb = json.traceback;
         if (tb !== undefined && tb.length > 0) {
             var s = '';
             var len = tb.length;
             for (var i=0; i<len; i++) {
                 s = s + tb[i] + '\n';
             }
             s = s + '\n';
             var toinsert = this.create_output_area();
             this.append_text(s, toinsert);
             this.element.find('div.output').append(toinsert);
         };
     };
 
 
     CodeCell.prototype.append_stream = function (json) {
         // temporary fix: if stream undefined (json file written prior to this patch),
         // default to most likely stdout:
         if (json.stream == undefined){
             json.stream = 'stdout';
         }
         var subclass = "output_"+json.stream;
         if (this.outputs.length > 0){
             // have at least one output to consider
             var last = this.outputs[this.outputs.length-1];
             if (last.output_type == 'stream' && json.stream == last.stream){
                 // latest output was in the same stream,
                 // so append directly into its pre tag
                 this.element.find('div.'+subclass).last().find('pre').append(json.text);
                 return;
             }
         }
         
         // If we got here, attach a new div
         var toinsert = this.create_output_area();
         this.append_text(json.text, toinsert, "output_stream "+subclass);
         this.element.find('div.output').append(toinsert);
     };
 
 
     CodeCell.prototype.append_display_data = function (json) {
         var toinsert = this.create_output_area();
         this.append_mime_type(json, toinsert);
         this.element.find('div.output').append(toinsert);
         // If we just output latex, typeset it.
         if ( (json.latex !== undefined) || (json.html !== undefined) ) {
-            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+            this.typeset();
         };
     };
 
 
     CodeCell.prototype.append_mime_type = function (json, element) {
         if (json.html !== undefined) {
             this.append_html(json.html, element);
         } else if (json.latex !== undefined) {
             this.append_latex(json.latex, element);
         } else if (json.svg !== undefined) {
             this.append_svg(json.svg, element);
         } else if (json.png !== undefined) {
             this.append_png(json.png, element);
         } else if (json.jpeg !== undefined) {
             this.append_jpeg(json.jpeg, element);
         } else if (json.text !== undefined) {
             this.append_text(json.text, element);
         };
     };
 
 
     CodeCell.prototype.append_html = function (html, element) {
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_html rendered_html");
         toinsert.append(html);
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.append_text = function (data, element, extra_class) {
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_text");
         if (extra_class){
             toinsert.addClass(extra_class);
         }
         toinsert.append($("<pre/>").html(data));
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.append_svg = function (svg, element) {
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_svg");
         toinsert.append(svg);
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.append_png = function (png, element) {
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_png");
         toinsert.append($("<img/>").attr('src','data:image/png;base64,'+png));
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.append_jpeg = function (jpeg, element) {
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_jpeg");
         toinsert.append($("<img/>").attr('src','data:image/jpeg;base64,'+jpeg));
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.append_latex = function (latex, element) {
         // This method cannot do the typesetting because the latex first has to
         // be on the page.
         var toinsert = $("<div/>").addClass("box_flex1 output_subarea output_latex");
         toinsert.append(latex);
         element.append(toinsert);
     };
 
 
     CodeCell.prototype.clear_output = function (stdout, stderr, other) {
         var output_div = this.element.find("div.output");
         if (stdout && stderr && other){
             // clear all, no need for logic
             output_div.html("");
             this.outputs = [];
             return;
         }
         // remove html output
         // each output_subarea that has an identifying class is in an output_area
         // which is the element to be removed.
         if (stdout){
             output_div.find("div.output_stdout").parent().remove();
         }
         if (stderr){
             output_div.find("div.output_stderr").parent().remove();
         }
         if (other){
             output_div.find("div.output_subarea").not("div.output_stderr").not("div.output_stdout").parent().remove();
         }
         
         // remove cleared outputs from JSON list:
         for (var i = this.outputs.length - 1; i >= 0; i--){
             var out = this.outputs[i];
             var output_type = out.output_type;
             if (output_type == "display_data" && other){
                 this.outputs.splice(i,1);
             }else if (output_type == "stream"){
                 if (stdout && out.stream == "stdout"){
                     this.outputs.splice(i,1);
                 }else if (stderr && out.stream == "stderr"){
                     this.outputs.splice(i,1);
                 }
             }
         }
     };
 
 
     CodeCell.prototype.clear_input = function () {
         this.code_mirror.setValue('');
     };
 
 
     CodeCell.prototype.collapse = function () {
         if (!this.collapsed) {
             this.element.find('div.output').hide();
             this.collapsed = true;
         };
     };
 
 
     CodeCell.prototype.expand = function () {
         if (this.collapsed) {
             this.element.find('div.output').show();
             this.collapsed = false;
         };
     };
 
 
     CodeCell.prototype.toggle_output = function () {
         if (this.collapsed) {
             this.expand();
         } else {
             this.collapse();
         };
     };
 
     CodeCell.prototype.set_input_prompt = function (number) {
         var n = number || '&nbsp;';
         this.input_prompt_number = n;
         this.element.find('div.input_prompt').html('In&nbsp;[' + n + ']:');
     };
 
 
     CodeCell.prototype.get_code = function () {
         return this.code_mirror.getValue();
     };
 
 
     CodeCell.prototype.set_code = function (code) {
         return this.code_mirror.setValue(code);
     };
 
 
     CodeCell.prototype.at_top = function () {
         var cursor = this.code_mirror.getCursor();
         if (cursor.line === 0) {
             return true;
         } else {
             return false;
         }
     };
 
 
     CodeCell.prototype.at_bottom = function () {
         var cursor = this.code_mirror.getCursor();
         if (cursor.line === (this.code_mirror.lineCount()-1)) {
             return true;
         } else {
             return false;
         }
     };
 
 
     CodeCell.prototype.fromJSON = function (data) {
         console.log('Import from JSON:', data);
         if (data.cell_type === 'code') {
             if (data.input !== undefined) {
                 this.set_code(data.input);
             }
             if (data.prompt_number !== undefined) {
                 this.set_input_prompt(data.prompt_number);
             } else {
                 this.set_input_prompt();
             };
             var len = data.outputs.length;
             for (var i=0; i<len; i++) {
                 this.append_output(data.outputs[i]);
             };
             if (data.collapsed !== undefined) {
                 if (data.collapsed) {
                     this.collapse();
                 };
             };
         };
     };
 
 
     CodeCell.prototype.toJSON = function () {
         var data = {};
         data.input = this.get_code();
         data.cell_type = 'code';
         if (this.input_prompt_number !== ' ') {
             data.prompt_number = this.input_prompt_number;
         };
         var outputs = [];
         var len = this.outputs.length;
         for (var i=0; i<len; i++) {
             outputs[i] = this.outputs[i];
         };
         data.outputs = outputs;
         data.language = 'python';
         data.collapsed = this.collapsed;
         // console.log('Export to JSON:',data);
         return data;
     };
 
 
     IPython.CodeCell = CodeCell;
 
     return IPython;
 }(IPython));

IPython/frontend/html/notebook/static/js/notebookmain.js

@@ -1,85 +1,131 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // On document ready
 //============================================================================
 
 
 $(document).ready(function () {
 
+    if (window.MathJax == undefined){
+        // MathJax undefined, but expected.  Draw warning.
+        window.MathJax = null;
+        var dialog = $('<div></div>').html(
+            "<p class='dialog'>"+
+            "We were unable to retrieve MathJax. Math/LaTeX rendering will be disabled."+
+            "</p>"+
+            "<p class='dialog'>"+
+            "With a working internet connection, you can run the following at a Python"+
+            " or IPython prompt, which will install a local copy of MathJax:"+
+            "</p>"+
+            "<pre class='dialog'>"+
+            ">>> from IPython.external import mathjax; mathjax.install_mathjax()"+
+            "</pre>"+
+            "<p class='dialog'>"+
+            "This will try to install MathJax into the directory where you installed"+
+            " IPython. If you installed IPython to a location that requires"+
+            " administrative privileges to write, you will need to make this call as"+
+            " an administrator."+
+            "</p>"+
+            "<p class='dialog'>"+
+            "On OSX/Linux/Unix, this can be done at the command-line via:"+
+            "</p>"+
+            "<pre class='dialog'>"+
+            "$ sudo python -c 'from IPython.external import mathjax; mathjax.install_mathjax()'"+
+            "</pre>"+
+            "<p class='dialog'>"+
+            "Or you can instruct the notebook server to start without MathJax support, with:"+
+            "<pre class='dialog'>"+
+            "</p>"+
+            "$ ipython notebook --no-mathjax"+
+            "</pre>"+
+            "<p class='dialog'>"+
+            "in which case, equations will not be rendered."+
+            "</p>"
+            ).dialog({
+                title: 'MathJax disabled',
+                width: "70%",
+                modal: true,
+            })
+    }else if (window.MathJax){
     MathJax.Hub.Config({
         tex2jax: {
             inlineMath: [ ['$','$'], ["\\(","\\)"] ],
             displayMath: [ ['$$','$$'], ["\\[","\\]"] ]
         },
         displayAlign: 'left', // Change this to 'center' to center equations.
         "HTML-CSS": {
             styles: {'.MathJax_Display': {"margin": 0}}
         }
     });
+    }else{
+        // window.MathJax == null
+        // --no-mathjax mode
+    }
+    
     IPython.markdown_converter = new Markdown.Converter();
     IPython.read_only = $('meta[name=read_only]').attr("content") == 'True';
 
     $('div#header').addClass('border-box-sizing');
     $('div#main_app').addClass('border-box-sizing ui-widget ui-widget-content');
     $('div#notebook_panel').addClass('border-box-sizing ui-widget');
 
     IPython.layout_manager = new IPython.LayoutManager();
     IPython.pager = new IPython.Pager('div#pager', 'div#pager_splitter');
     IPython.left_panel = new IPython.LeftPanel('div#left_panel', 'div#left_panel_splitter');
     IPython.save_widget = new IPython.SaveWidget('span#save_widget');
     IPython.quick_help = new IPython.QuickHelp('span#quick_help_area');
     IPython.login_widget = new IPython.LoginWidget('span#login_widget');
     IPython.print_widget = new IPython.PrintWidget('span#print_widget');
     IPython.notebook = new IPython.Notebook('div#notebook');
     IPython.kernel_status_widget = new IPython.KernelStatusWidget('#kernel_status');
     IPython.kernel_status_widget.status_idle();
 
     IPython.layout_manager.do_resize();
 
     // These have display: none in the css file and are made visible here to prevent FLOUC.
     $('div#header').css('display','block');
 
     if(IPython.read_only){
         // hide various elements from read-only view
         IPython.save_widget.element.find('button#save_notebook').addClass('hidden');
         IPython.quick_help.element.addClass('hidden'); // shortcuts are disabled in read_only
         $('button#new_notebook').addClass('hidden');
         $('div#cell_section').addClass('hidden');
         $('div#config_section').addClass('hidden');
         $('div#kernel_section').addClass('hidden');
         $('span#login_widget').removeClass('hidden');
         // left panel starts collapsed, but the collapse must happen after
         // elements start drawing.  Don't draw contents of the panel until
         // after they are collapsed
         IPython.left_panel.left_panel_element.css('visibility', 'hidden');
     }
 
     $('div#main_app').css('display','block');
 
     // Perform these actions after the notebook has been loaded.
     // We wait 100 milliseconds because the notebook scrolls to the top after a load
     // is completed and we need to wait for that to mostly finish.
     IPython.notebook.load_notebook(function () {
         setTimeout(function () {
             IPython.save_widget.update_url();
             IPython.layout_manager.do_resize();
             IPython.pager.collapse();
             if(IPython.read_only){
                 // collapse the left panel on read-only
                 IPython.left_panel.collapse();
                 // and finally unhide the panel contents after collapse
                 setTimeout(function(){
                     IPython.left_panel.left_panel_element.css('visibility', 'visible');
                 }, 200);
             }
         },100);
     });
 
 });
 

IPython/frontend/html/notebook/static/js/textcell.js

@@ -1,272 +1,272 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // TextCell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     // TextCell base class
 
     var TextCell = function (notebook) {
         this.code_mirror_mode = this.code_mirror_mode || 'htmlmixed';
         this.placeholder = this.placeholder || '\u0000';
         IPython.Cell.apply(this, arguments);
         this.rendered = false;
         this.cell_type = this.cell_type || 'text';
     };
 
 
     TextCell.prototype = new IPython.Cell();
 
 
     TextCell.prototype.create_element = function () {
         var cell = $("<div>").addClass('cell text_cell border-box-sizing');
         cell.attr('tabindex','2');
         var input_area = $('<div/>').addClass('text_cell_input');
         this.code_mirror = CodeMirror(input_area.get(0), {
             indentUnit : 4,
             mode: this.code_mirror_mode,
             theme: 'default',
             value: this.placeholder,
             readOnly: this.read_only
         });
         // The tabindex=-1 makes this div focusable.
         var render_area = $('<div/>').addClass('text_cell_render').
             addClass('rendered_html').attr('tabindex','-1');
         cell.append(input_area).append(render_area);
         this.element = cell;
     };
 
 
     TextCell.prototype.bind_events = function () {
         IPython.Cell.prototype.bind_events.apply(this);
         var that = this;
         this.element.keydown(function (event) {
             if (event.which === 13) {
                 if (that.rendered) {
                     that.edit();
                     event.preventDefault();
                 }
             }
         });
     };
 
 
     TextCell.prototype.select = function () {
         IPython.Cell.prototype.select.apply(this);
         var output = this.element.find("div.text_cell_render");
         output.trigger('focus');
     };
 
 
     TextCell.prototype.edit = function () {
         if ( this.read_only ) return;
         if (this.rendered === true) {
             var text_cell = this.element;
             var output = text_cell.find("div.text_cell_render");  
             output.hide();
             text_cell.find('div.text_cell_input').show();
             this.code_mirror.focus();
             this.code_mirror.refresh();
             this.rendered = false;
             if (this.get_source() === this.placeholder) {
                 this.set_source('');
             }
         }
     };
 
 
     // Subclasses must define render.
     TextCell.prototype.render = function () {};
 
 
     TextCell.prototype.config_mathjax = function () {
         var text_cell = this.element;
         var that = this;
         text_cell.click(function () {
             that.edit();
         }).focusout(function () {
             that.render();
         });
         
         text_cell.trigger("focusout");
     };
 
 
     TextCell.prototype.get_source = function() {
         return this.code_mirror.getValue();
     };
 
 
     TextCell.prototype.set_source = function(text) {
         this.code_mirror.setValue(text);
         this.code_mirror.refresh();
     };
 
 
     TextCell.prototype.get_rendered = function() {
         return this.element.find('div.text_cell_render').html();
     };
 
 
     TextCell.prototype.set_rendered = function(text) {
         this.element.find('div.text_cell_render').html(text);
     };
 
 
     TextCell.prototype.at_top = function () {
         if (this.rendered) {
             return true;
         } else {
             return false;
         }
     };
 
 
     TextCell.prototype.at_bottom = function () {
         if (this.rendered) {
             return true;
         } else {
             return false;
         }
     };
 
 
     TextCell.prototype.fromJSON = function (data) {
         if (data.cell_type === this.cell_type) {
             if (data.source !== undefined) {
                 this.set_source(data.source);
                 this.set_rendered(data.rendered || '');
                 this.rendered = false;
                 this.render();
             }
         }
     };
 
 
     TextCell.prototype.toJSON = function () {
         var data = {};
         data.cell_type = this.cell_type;
         data.source = this.get_source();
         return data;
     };
 
 
     // HTMLCell
 
     var HTMLCell = function (notebook) {
         this.placeholder = "\u0000Type <strong>HTML</strong> and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'html';
     };
 
 
     HTMLCell.prototype = new TextCell();
 
 
     HTMLCell.prototype.render = function () {
         if (this.rendered === false) {
             var text = this.get_source();
             if (text === "") { text = this.placeholder; }
             this.set_rendered(text);
-            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+            this.typeset();
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             this.rendered = true;
         }
     };
 
 
     // MarkdownCell
 
     var MarkdownCell = function (notebook) {
         this.placeholder = "\u0000Type *Markdown* and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'markdown';
     };
 
 
     MarkdownCell.prototype = new TextCell();
 
 
     MarkdownCell.prototype.render = function () {
         if (this.rendered === false) {
             var text = this.get_source();
             if (text === "") { text = this.placeholder; }
             var html = IPython.markdown_converter.makeHtml(text);
             this.set_rendered(html);
-            MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+            this.typeset()
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             var code_snippets = this.element.find("pre > code");
             code_snippets.replaceWith(function () {
                 var code = $(this).html();
                 /* Substitute br for newlines and &nbsp; for spaces
                    before highlighting, since prettify doesn't
                    preserve those on all browsers */
                 code = code.replace(/(\r\n|\n|\r)/gm, "<br/>");
                 code = code.replace(/ /gm, '&nbsp;');
                 code = prettyPrintOne(code);
 
                 return '<code class="prettyprint">' + code + '</code>';
             });
             this.rendered = true;
         }
     };
 
 
     // RSTCell
 
     var RSTCell = function (notebook) {
         this.placeholder = "\u0000Type *ReStructured Text* and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'rst';
     };
 
 
     RSTCell.prototype = new TextCell();
 
 
     RSTCell.prototype.render = function () {
         if (this.rendered === false) {
             var text = this.get_source();
             if (text === "") { text = this.placeholder; }
             var settings = {
                 processData : false,
                 cache : false,
                 type : "POST",
                 data : text,
                 headers : {'Content-Type': 'application/x-rst'},
                 success : $.proxy(this.handle_render,this)
             };
             $.ajax("/rstservice/render", settings);
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             this.set_rendered("Rendering...");
         }
     };
 
 
     RSTCell.prototype.handle_render = function (data, status, xhr) {
         this.set_rendered(data);
-        MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+        this.typeset();
         this.rendered = true;
     };
 
 
     IPython.TextCell = TextCell;
     IPython.HTMLCell = HTMLCell;
     IPython.MarkdownCell = MarkdownCell;
     IPython.RSTCell = RSTCell;
 
 
     return IPython;
 
 }(IPython));
 

IPython/frontend/html/notebook/templates/notebook.html

@@ -1,327 +1,303 b''
 <!DOCTYPE HTML>
 <html>
 
 <head>
     <meta charset="utf-8">
 
     <title>IPython Notebook</title>
 
+    {% if enable_mathjax %}
     <!-- <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML" charset="utf-8"></script> -->
     <script type='text/javascript' src='static/mathjax/MathJax.js?config=TeX-AMS_HTML' charset='utf-8'></script>
     <script type="text/javascript">
-    function CheckMathJax(){
-        var div=document.getElementById("MathJaxFetchingWarning")
-        if(window.MathJax){
-            document.body.removeChild(div)
-        }
-        else{
-           div.style.display = "block";
-        }
-    }
-    if (typeof MathJax == 'undefined') {
+    if (typeof(MathJax) == 'undefined') {
         console.log("No local MathJax, loading from CDN");
         document.write(unescape("%3Cscript type='text/javascript' src='http://cdn.mathjax.org/mathjax/latest/MathJax.js%3Fconfig=TeX-AMS_HTML' charset='utf-8'%3E%3C/script%3E"));
     }else{
         console.log("Using local MathJax");
     }
     </script>
+    {% else %}
+    <script type="text/javascript">
+    // MathJax disabled, set as null to distingish from *missing* MathJax,
+    // where it will be undefined, and should prompt a dialog later.
+    window.MathJax = null;
+    </script>
+    {% end %}
 
     <link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
     <link rel="stylesheet" href="static/codemirror/lib/codemirror.css">
     <link rel="stylesheet" href="static/codemirror/mode/markdown/markdown.css">
     <link rel="stylesheet" href="static/codemirror/mode/rst/rst.css">
     <link rel="stylesheet" href="static/codemirror/theme/ipython.css">
     <link rel="stylesheet" href="static/codemirror/theme/default.css">
 
     <link rel="stylesheet" href="static/prettify/prettify.css"/>
 
     <link rel="stylesheet" href="static/css/boilerplate.css" type="text/css" />
     <link rel="stylesheet" href="static/css/layout.css" type="text/css" />
     <link rel="stylesheet" href="static/css/base.css" type="text/css" />
     <link rel="stylesheet" href="static/css/notebook.css" type="text/css" />
     <link rel="stylesheet" href="static/css/renderedhtml.css" type="text/css" />
     
     <meta name="read_only" content="{{read_only}}"/>
 
 </head>
 
-<body onload='CheckMathJax();'
+<body
     data-project={{project}} data-notebook-id={{notebook_id}}
     data-base-project-url={{base_project_url}} data-base-kernel-url={{base_kernel_url}}
 >
 
 <div id="header">
     <span id="ipython_notebook"><h1>IPython Notebook</h1></span>
     <span id="save_widget">
         <input type="text" id="notebook_name" size="20"></textarea>
         <button id="save_notebook"><u>S</u>ave</button>
     </span>
     <span id="quick_help_area">
       <button id="quick_help">Quick<u>H</u>elp</button>
     </span>
 
     <span id="login_widget">
       {% comment  This is a temporary workaround to hide the logout button %}
       {% comment  when appropriate until notebook.html is templated %}
       {% if current_user and current_user != 'anonymous' %}
         <button id="logout">Logout</button>
       {% end %}
     </span>
 
     <span id="kernel_status">Idle</span>
 </div>
 
-<div id="MathJaxFetchingWarning"
-      style="width:80%; margin:auto;padding-top:20%;text-align: justify; display:none">
-      <p style="font-size:26px;">There was an issue trying to fetch MathJax.js
-        from the internet.</p>
-
-      <p style="padding:0.2em"> With a working internet connection, you can run
-    the following at a Python or IPython prompt, which will install a local
-    copy of MathJax:</p>
-      
-        <pre style="background-color:lightblue;border:thin silver solid;padding:0.4em">
-            from IPython.external import mathjax; mathjax.install_mathjax()
-        </pre>
-        This will try to install MathJax into the directory where you installed
-        IPython. If you installed IPython to a location that requires
-        administrative privileges to write, you will need to make this call as
-        an administrator. On OSX/Linux/Unix, this can be done at the
-        command-line via:
-        <pre style="background-color:lightblue;border:thin silver solid;padding:0.4em">
-            sudo python -c "from IPython.external import mathjax; mathjax.install_mathjax()"
-        </pre>
-    </p>
-</div>
-
 <div id="main_app">
 
     <div id="left_panel">
 
         <div id="notebook_section">
             <div class="section_header">
                 <h3>Notebook</h3>
             </div>
             <div class="section_content">
                 <div class="section_row">
                     <span id="new_open" class="section_row_buttons">
                         <button id="new_notebook">New</button>
                         <button id="open_notebook">Open</button>
                     </span>
                     <span class="section_row_header">Actions</span>
                 </div>
                 <div class="section_row">
                     <span>
                         <select id="download_format">
                             <option value="json">ipynb</option>
                             <option value="py">py</option>
                         </select>
                     </span>
                     <span class="section_row_buttons">
                         <button id="download_notebook">Download</button>
                     </span>
                 </div>
                 <div class="section_row">
                     <span class="section_row_buttons">
                         <span id="print_widget">
                             <button id="print_notebook">Print</button>
                         </span>
                     </span>
                 </div>
             </div>
         </div>
 
         <div id="cell_section">
             <div class="section_header">
                 <h3>Cell</h3>
             </div>
             <div class="section_content">
                 <div class="section_row">
                     <span class="section_row_buttons">
                         <button id="delete_cell"><u>D</u>elete</button>
                     </span>
                     <span class="section_row_header">Actions</span>
                 </div>
                 <div class="section_row">
                     <span id="cell_type" class="section_row_buttons">
                         <button id="to_code"><u>C</u>ode</button>
 <!--                        <button id="to_html">HTML</button>-->
                         <button id="to_markdown"><u>M</u>arkdown</button>
                     </span>
                      <span class="button_label">Format</span> 
                 </div>
                 <div class="section_row">
                     <span id="cell_output" class="section_row_buttons">
                         <button id="toggle_output"><u>T</u>oggle</button>
                         <button id="clear_all_output">ClearAll</button>
                     </span>
                     <span class="button_label">Output</span>
                 </div>
                 <div class="section_row">
                     <span id="insert" class="section_row_buttons">
                         <button id="insert_cell_above"><u>A</u>bove</button>
                         <button id="insert_cell_below"><u>B</u>elow</button>
                     </span>
                     <span class="button_label">Insert</span>
                 </div>
                 <div class="section_row">
                     <span id="move" class="section_row_buttons">
                         <button id="move_cell_up">Up</button>
                         <button id="move_cell_down">Down</button>
                     </span>
                     <span class="button_label">Move</span>
                 </div>
                 <div class="section_row">
                     <span id="run_cells" class="section_row_buttons">
                         <button id="run_selected_cell">Selected</button>
                         <button id="run_all_cells">All</button>
                     </span>
                     <span class="button_label">Run</span>
                 </div>
                 <div class="section_row">
                     <span id="autoindent_span">
                         <input type="checkbox" id="autoindent" checked="true"></input>
                     </span>
                     <span class="checkbox_label" id="autoindent_label">Autoindent:</span>
                 </div>
             </div>
         </div>
 
         <div id="kernel_section">
             <div class="section_header">
                 <h3>Kernel</h3>
             </div>
             <div class="section_content">
                 <div class="section_row">
                     <span id="int_restart" class="section_row_buttons">
                         <button id="int_kernel"><u>I</u>nterrupt</button>
                         <button id="restart_kernel">Restart</button>
                     </span>
                     <span class="section_row_header">Actions</span>
                 </div>
                 <div class="section_row">
                     <span id="kernel_persist">
                         {% if kill_kernel %}
                             <input type="checkbox" id="kill_kernel" checked="true"></input>
                         {% else %}
                             <input type="checkbox" id="kill_kernel"></input>
                         {% end %}
                     </span>
                     <span class="checkbox_label" id="kill_kernel_label">Kill kernel upon exit:</span>
                 </div>
             </div>
         </div>
 
         <div id="help_section">
             <div class="section_header">
                 <h3>Help</h3>
             </div>
             <div class="section_content">
                 <div class="section_row">
                     <span id="help_buttons0" class="section_row_buttons">
                         <a id="python_help" href="http://docs.python.org" target="_blank">Python</a>
                         <a id="ipython_help" href="http://ipython.org/documentation.html" target="_blank">IPython</a>
                     </span>
                     <span class="section_row_header">Links</span>
                 </div>
                 <div class="section_row">
                     <span id="help_buttons1" class="section_row_buttons">
                         <a id="numpy_help" href="http://docs.scipy.org/doc/numpy/reference/" target="_blank">NumPy</a>
                         <a id="scipy_help" href="http://docs.scipy.org/doc/scipy/reference/" target="_blank">SciPy</a>
                     </span>
                 </div>
                 <div class="section_row">
                     <span id="help_buttons2" class="section_row_buttons">
                         <a id="matplotlib_help" href="http://matplotlib.sourceforge.net/" target="_blank">MPL</a>
                         <a id="sympy_help" href="http://docs.sympy.org/dev/index.html" target="_blank">SymPy</a>
                     </span>
                 </div>
                 <div class="section_row">
                     <span class="help_string">run selected cell</span>
                     <span class="help_string_label">Shift-Enter :</span>
                 </div>
                 <div class="section_row">
                     <span class="help_string">run selected cell in-place</span>
                     <span class="help_string_label">Ctrl-Enter  :</span>
                 </div>
                 <div class="section_row">
                     <span class="help_string">show keyboard shortcuts</span>
                     <span class="help_string_label">Ctrl-m h  :</span>
                 </div>
             </div>
         </div>
 
         <div id="config_section">
             <div class="section_header">
                 <h3>Config</h3>
             </div>
             <div class="section_content">
                 <div class="section_row">
                     <span id="tooltipontab_span">
                         <input type="checkbox" id="tooltipontab" checked="true"></input>
                     </span>
                     <span class="checkbox_label" id="tooltipontab_label">Tooltip on tab:</span>
                 </div>
                 <div class="section_row">
                     <span id="smartcompleter_span">
                         <input type="checkbox" id="smartcompleter" checked="true"></input>
                     </span>
                     <span class="checkbox_label" id="smartcompleter_label">Smart completer:</span>
                 </div>
                 <div class="section_row">
                     <span id="timebeforetooltip_span">
                         <input type="text" id="timebeforetooltip" value="1200"></input>
                     </span>
                     <span class="numeric_input_label" id="timebeforetooltip_label">Time before tooltip : </span>
                 </div>
             </div>
         </div>
 
     </div>
     <div id="left_panel_splitter"></div>
     <div id="notebook_panel">
         <div id="notebook"></div>
         <div id="pager_splitter"></div>
         <div id="pager"></div>
     </div>
 
 </div>
 
 <script src="static/jquery/js/jquery-1.6.2.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/jquery/js/jquery-ui-1.8.14.custom.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/jquery/js/jquery.autogrow.js" type="text/javascript" charset="utf-8"></script>
 
 <script src="static/codemirror/lib/codemirror.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/python/python.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/htmlmixed/htmlmixed.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/xml/xml.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/javascript/javascript.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/css/css.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/rst/rst.js" charset="utf-8"></script>
 <script src="static/codemirror/mode/markdown/markdown.js" charset="utf-8"></script>
 
 <script src="static/pagedown/Markdown.Converter.js" charset="utf-8"></script>
 
 <script src="static/prettify/prettify.js" charset="utf-8"></script>
 
 <script src="static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/utils.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/cell.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/codecell.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/textcell.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/kernel.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/kernelstatus.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/layout.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/savewidget.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/quickhelp.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/loginwidget.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/pager.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/panelsection.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/printwidget.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/leftpanel.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/notebook.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/notebookmain.js" type="text/javascript" charset="utf-8"></script>
 
 </body>
 
 </html>