add read-only view for notebooks

When using a password, read-only mode allows unauthenticated users
read-only access to notebooks.  Editing, execution, etc. are not
allowed in read-only mode, but save/print functions are available.

No kernels are started until an authenticated user opens a notebook.

IPython/frontend/html/notebook/handlers.py

@@ -1,470 +1,491 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
 
 try:
     from docutils.core import publish_string
 except ImportError:
     publish_string = None
 
 
 #-----------------------------------------------------------------------------
 # Decorator for disabling read-only handlers
 #-----------------------------------------------------------------------------
 
 @decorator
 def not_if_readonly(f, self, *args, **kwargs):
     if self.application.ipython_app.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.ipython_app.read_only:
+        return f(self, *args, **kwargs)
+    else:
+        return auth_f(self, *args, **kwargs)
+
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 
 class AuthenticatedHandler(web.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:
                 user_id = 'anonymous'
         return user_id
 
 
 class ProjectDashboardHandler(AuthenticatedHandler):
 
-    @web.authenticated
+    @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'/'
         )
 
 
 class LoginHandler(AuthenticatedHandler):
 
     def get(self):
-        self.render('login.html', next='/')
+        self.render('login.html', next=self.get_argument('next', default='/'))
 
     def post(self):
         pwd = self.get_argument('password', default=u'')
         if self.application.password and pwd == self.application.password:
             self.set_secure_cookie('username', str(uuid.uuid4()))
         url = self.get_argument('next', default='/')
         self.redirect(url)
 
 
 class NewHandler(AuthenticatedHandler):
 
-    @not_if_readonly
     @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
         )
 
 
 class NamedNotebookHandler(AuthenticatedHandler):
 
-    @web.authenticated
+    @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
         )
 
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(AuthenticatedHandler):
 
-    @not_if_readonly
     @web.authenticated
     def get(self):
         km = self.application.kernel_manager
         self.finish(jsonapi.dumps(km.kernel_ids))
 
-    @not_if_readonly
     @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)
         ws_url = self.application.ipython_app.get_ws_url()
         data = {'ws_url':ws_url,'kernel_id':kernel_id}
         self.set_header('Location', '/'+kernel_id)
         self.finish(jsonapi.dumps(data))
 
 
 class KernelHandler(AuthenticatedHandler):
 
     SUPPORTED_METHODS = ('DELETE')
 
-    @not_if_readonly
     @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):
 
-    @not_if_readonly
     @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)
             ws_url = self.application.ipython_app.get_ws_url()
             data = {'ws_url':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)
 
-    @not_if_readonly
     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):
 
-    @web.authenticated
+    @authenticate_unless_readonly
     def get(self):
+        
+        # communicate read-only via Allow header
+        if self.application.ipython_app.read_only and not self.get_current_user():
+            self.set_header('Allow', 'GET')
+        else:
+            self.set_header('Allow', ', '.join(self.SUPPORTED_METHODS))
+        
         nbm = self.application.notebook_manager
         files = nbm.list_notebooks()
         self.finish(jsonapi.dumps(files))
 
-    @not_if_readonly
     @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')
 
-    @web.authenticated
+    @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)
+        
+        # communicate read-only via Allow header
+        if self.application.ipython_app.read_only and not self.get_current_user():
+            self.set_header('Allow', 'GET')
+        else:
+            self.set_header('Allow', ', '.join(self.SUPPORTED_METHODS))
+        
         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)
 
-    @not_if_readonly
     @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()
 
-    @not_if_readonly
     @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,323 +1,332 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
 #-----------------------------------------------------------------------------
 
 import errno
 import logging
 import os
 import signal
 import socket
 import sys
 import webbrowser
 
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 import tornado.ioloop
 tornado.ioloop.IOLoop = ioloop.IOLoop
 
 from tornado import httpserver
 from tornado import web
 
 from .kernelmanager import MappingKernelManager
 from .handlers import (LoginHandler,
     ProjectDashboardHandler, NewHandler, NamedNotebookHandler,
     MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler,
     ShellHandler, NotebookRootHandler, NotebookHandler, RSTHandler
 )
 from .notebookmanager import NotebookManager
 
 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, Int, 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"/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
 
 
 #-----------------------------------------------------------------------------
 # 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['read-only'] = (
     {'NotebookApp' : {'read_only' : True}},
-    "Launch the Notebook server in read-only mode, not allowing execution or editing"
+    """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.
+    
+    This flag only makes sense in conjunction with setting a password,
+    via the ``NotebookApp.password`` configurable.
+    """
 )
 
 # 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']
+notebook_flags = ['no-browser', 'read-only']
 
 aliases = dict(ipkernel_aliases)
 
 aliases.update({
     'ip': 'NotebookApp.ip',
     'port': 'NotebookApp.port',
     'keyfile': 'NotebookApp.keyfile',
     'certfile': 'NotebookApp.certfile',
     'ws-hostname': 'NotebookApp.ws_hostname',
     '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'ws-hostname',
                     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 = Int(8888, config=True,
         help="The port the notebook server will listen on."
     )
 
     ws_hostname = Unicode(LOCALHOST, config=True,
         help="""The FQDN or IP for WebSocket connections. The default will work
                 fine when the server is listening on localhost, but this needs to
                 be set if the ip option is used. It will be used as the hostname part
                 of the WebSocket url: ws://hostname/path."""
     )
 
     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="""Password to use for web authentication"""
     )
     
     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."
     )
 
     def get_ws_url(self):
         """Return the WebSocket URL for this server."""
         if self.certfile:
             prefix = u'wss://'
         else:
             prefix = u'ws://'
         return prefix + self.ws_hostname + u':' + unicode(self.port)
 
     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
 
     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'
             webbrowser.open("%s://%s:%i" % (proto, ip, self.port), new=2)
         ioloop.IOLoop.instance().start()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def launch_new_instance():
     app = NotebookApp()
     app.initialize()
     app.start()
 

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

@@ -1,53 +1,62 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;
 }
 
 
 div#header {
     /* Initially hidden to prevent FLOUC */
     display: none;
     position: relative;
     height: 40px;
     padding: 5px;
     margin: 0px;
     width: 100%;
 }
 
 span#ipython_notebook {
     position: absolute;
     padding: 2px;
 }
 
 span#ipython_notebook h1 {
     font-family: Verdana, "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     font-size: 150%;
     display: inline;
     color: black;
 }
 
 div#main_app {
     /* Initially hidden to prevent FLOUC */
     display: none;
     width: 100%;
     position: relative;
 }
 
 .ui-button .ui-button-text {
     padding: 0.2em 0.8em;
     font-size: 77%;
 }
+
+span#login_widget {
+    float: right;
+}
+
+/* generic class for hidden objects */
+.hidden {
+    display: none;
+}
  No newline at end of file

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

@@ -1,93 +1,97 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 () {};
 
     IPython.Cell = Cell;
 
     return IPython;
 
 }(IPython));
 

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

@@ -1,518 +1,519 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()
     };
 
 
     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.
         if (event.keyCode === 13 && (event.shiftKey || event.ctrlKey)) {
             // Always ignore shift-enter in CodeMirror as we handle it.
             return true;
         } else if (event.keyCode === 9 && event.type == 'keydown') {
             // Tab completion.
             var cur = editor.getCursor();
             var pre_cursor = editor.getRange({line:cur.line,ch:0},cur).trim();
             if (pre_cursor === "") {
                 // Don't autocomplete if the part of the line before the cursor
                 // is empty.  In this case, let CodeMirror handle indentation.
                 return false;
             } else {
                 // 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;
         };
     };
 
 
     CodeCell.prototype.finish_completing = function (matched_text, matches) {
         // console.log("Got matches", matched_text, matches);
         if (!this.is_completing || matches.length === 0) {return;}
 
         var that = this;
         var cur = this.completion_cursor;
 
         var insert = function (selected_text) {
             that.code_mirror.replaceRange(
                 selected_text,
                 {line: cur.line, ch: (cur.ch-matched_text.length)},
                 {line: cur.line, ch: cur.ch}
             );
         };
 
         if (matches.length === 1) {
             insert(matches[0]);
             setTimeout(function(){that.code_mirror.focus();}, 50);
             return;
         };
 
         var complete = $('<div/>').addClass('completions');
         var select = $('<select/>').attr('multiple','true');
         for (var i=0; i<matches.length; ++i) {
             select.append($('<option/>').text(matches[i]));
         }
         select.children().first().attr('selected','true');
         select.attr('size',Math.min(10,matches.length));
         var pos = this.code_mirror.cursorCoords();
         complete.css('left',pos.x+'px');
         complete.css('top',pos.yBot+'px');
         complete.append(select);
 
         $('body').append(complete);
         var done = false;
 
         var close = function () {
             if (done) return;
             done = true;
             complete.remove();
             that.is_completing = false;
             that.completion_cursor = null;
         };
 
         var pick = function () {
             insert(select.val()[0]);
             close();
             setTimeout(function(){that.code_mirror.focus();}, 50);
         };
 
         select.blur(close);
         select.keydown(function (event) {
             var code = event.which;
             if (code === 13 || code === 32) {
                 // 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 {
                 // All other key presses exit completion.
                 event.stopPropagation();
                 event.preventDefault();
                 close();
                 that.code_mirror.focus();
             }
         });
         // Double click also causes a pick.
         select.dblclick(pick);
         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) {
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
         };
     };
 
 
     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) {
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
         };
     };
 
 
     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 || ' ';
         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/notebook.js

@@ -1,1001 +1,1025 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.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Notebook = function (selector) {
+        this.read_only = false;
         this.element = $(selector);
         this.element.scroll();
         this.element.data("notebook", this);
         this.next_prompt_number = 1;
         this.kernel = null;
         this.dirty = false;
         this.msg_cell_map = {};
         this.metadata = {};
         this.control_key_active = false;
         this.style();
         this.create_elements();
         this.bind_events();
     };
 
 
     Notebook.prototype.style = function () {
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.create_elements = function () {
         // We add this end_space div to the end of the notebook div to:
         // i) provide a margin between the last cell and the end of the notebook
         // ii) to prevent the div from scrolling up when the last cell is being
         // edited, but is too low on the page, which browsers will do automatically.
         var that = this;
         var end_space = $('<div class="end_space"></div>').height(150);
         end_space.dblclick(function (e) {
+            if (that.read_only) return;
             var ncells = that.ncells();
             that.insert_code_cell_below(ncells-1);
         });
         this.element.append(end_space);
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
             // console.log(event);
+            if (that.read_only) return;
             if (event.which === 38) {
                 var cell = that.selected_cell();
                 if (cell.at_top()) {
                     event.preventDefault();
                     that.select_prev();
                 };
             } else if (event.which === 40) {
                 var cell = that.selected_cell();
                 if (cell.at_bottom()) {
                     event.preventDefault();
                     that.select_next();
                 };
             } else if (event.which === 13 && event.shiftKey) {
                 that.execute_selected_cell();
                 return false;
             } else if (event.which === 13 && event.ctrlKey) {
                 that.execute_selected_cell({terminal:true});
                 return false;
             } else if (event.which === 77 && event.ctrlKey) {
                 that.control_key_active = true;
                 return false;
             } else if (event.which === 68 && that.control_key_active) {
                 // Delete selected cell = d
                 that.delete_cell();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 65 && that.control_key_active) {
                 // Insert code cell above selected = a
                 that.insert_code_cell_above();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 66 && that.control_key_active) {
                 // Insert code cell below selected = b
                 that.insert_code_cell_below();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 67 && that.control_key_active) {
                 // To code = c
                 that.to_code();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 77 && that.control_key_active) {
                 // To markdown = m
                 that.to_markdown();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 84 && that.control_key_active) {
                 // Toggle output = t
                 that.toggle_output();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 83 && that.control_key_active) {
                 // Save notebook = s
                 IPython.save_widget.save_notebook();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 74 && that.control_key_active) {
                 // Move cell down = j
                 that.move_cell_down();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 75 && that.control_key_active) {
                 // Move cell up = k
                 that.move_cell_up();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 80 && that.control_key_active) {
                 // Select previous = p
                 that.select_prev();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 78 && that.control_key_active) {
                 // Select next = n
                 that.select_next();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 76 && that.control_key_active) {
                 // Toggle line numbers = l
                 that.cell_toggle_line_numbers();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 73 && that.control_key_active) {
                 // Interrupt kernel = i
                 IPython.notebook.kernel.interrupt();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 190 && that.control_key_active) {
                 // Restart kernel = .  # matches qt console
                 IPython.notebook.restart_kernel();
                 that.control_key_active = false;
                 return false;
             } else if (event.which === 72 && that.control_key_active) {
                 // Show keyboard shortcuts = h
                 that.toggle_keyboard_shortcuts();
                 that.control_key_active = false;
                 return false;
             } else if (that.control_key_active) {
                 that.control_key_active = false;
                 return true;
             };
         });
 
         this.element.bind('collapse_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var new_height = app_height - splitter_height;
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('expand_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var pager_height = $('div#pager').outerHeight(true);
             var new_height = app_height - pager_height - splitter_height; 
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('collapse_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var new_margin = splitter_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
 
         this.element.bind('expand_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var left_panel_width = IPython.left_panel.width;
             var new_margin = splitter_width + left_panel_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
 
         $(window).bind('beforeunload', function () {
             var kill_kernel = $('#kill_kernel').prop('checked');                
             if (kill_kernel) {
                 that.kernel.kill();
             }
-            if (that.dirty) {
+            if (that.dirty && ! that.read_only) {
                 return "You have unsaved changes that will be lost if you leave this page.";
             };
         });
     };
 
 
     Notebook.prototype.toggle_keyboard_shortcuts = function () {
         // toggles display of keyboard shortcut dialog
         var that = this;
         if ( this.shortcut_dialog ){
             // if dialog is already shown, close it
             this.shortcut_dialog.dialog("close");
             this.shortcut_dialog = null;
             return;
         }
         var dialog = $('<div/>');
         this.shortcut_dialog = dialog;
         var shortcuts = [
             {key: 'Shift-Enter', help: 'run cell'},
             {key: 'Ctrl-Enter', help: 'run cell in-place'},
             {key: 'Ctrl-m d', help: 'delete cell'},
             {key: 'Ctrl-m a', help: 'insert cell above'},
             {key: 'Ctrl-m b', help: 'insert cell below'},
             {key: 'Ctrl-m t', help: 'toggle output'},
             {key: 'Ctrl-m l', help: 'toggle line numbers'},
             {key: 'Ctrl-m s', help: 'save notebook'},
             {key: 'Ctrl-m j', help: 'move cell down'},
             {key: 'Ctrl-m k', help: 'move cell up'},
             {key: 'Ctrl-m c', help: 'code cell'},
             {key: 'Ctrl-m m', help: 'markdown cell'},
             {key: 'Ctrl-m p', help: 'select previous'},
             {key: 'Ctrl-m n', help: 'select next'},
             {key: 'Ctrl-m i', help: 'interrupt kernel'},
             {key: 'Ctrl-m .', help: 'restart kernel'},
             {key: 'Ctrl-m h', help: 'show keyboard shortcuts'}
         ];
         for (var i=0; i<shortcuts.length; i++) {
             dialog.append($('<div>').
                 append($('<span/>').addClass('shortcut_key').html(shortcuts[i].key)).
                 append($('<span/>').addClass('shortcut_descr').html(' : ' + shortcuts[i].help))
             );
         };
         dialog.bind('dialogclose', function(event) {
             // dialog has been closed, allow it to be drawn again.
             that.shortcut_dialog = null;
         });
         dialog.dialog({title: 'Keyboard shortcuts'});
     };
 
 
     Notebook.prototype.scroll_to_bottom = function () {
         this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0);
     };
 
 
     Notebook.prototype.scroll_to_top = function () {
         this.element.animate({scrollTop:0}, 0);
     };
 
 
     // Cell indexing, retrieval, etc.
 
 
     Notebook.prototype.cell_elements = function () {
         return this.element.children("div.cell");
     }
 
 
     Notebook.prototype.ncells = function (cell) {
         return this.cell_elements().length;
     }
 
 
     // TODO: we are often calling cells as cells()[i], which we should optimize
     // to cells(i) or a new method.
     Notebook.prototype.cells = function () {
         return this.cell_elements().toArray().map(function (e) {
             return $(e).data("cell");
         });
     }
 
 
     Notebook.prototype.find_cell_index = function (cell) {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell") === cell) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.index_or_selected = function (index) {
         return index || this.selected_index() || 0;
     }
 
 
     Notebook.prototype.select = function (index) {
         if (index !== undefined && index >= 0 && index < this.ncells()) {
             if (this.selected_index() !== null) {
                 this.selected_cell().unselect();
             };
             this.cells()[index].select();
         };
         return this;
     };
 
 
     Notebook.prototype.select_next = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index+1) < this.ncells()) {
             this.select(index+1);
         };
         return this;
     };
 
 
     Notebook.prototype.select_prev = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index-1) < this.ncells()) {
             this.select(index-1);
         };
         return this;
     };
 
 
     Notebook.prototype.selected_index = function () {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell").selected === true) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.cell_for_msg = function (msg_id) {
         var cell_id = this.msg_cell_map[msg_id];
         var result = null;
         this.cell_elements().filter(function (index) {
             cell = $(this).data("cell");
             if (cell.cell_id === cell_id) {
                 result = cell;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.selected_cell = function () {
         return this.cell_elements().eq(this.selected_index()).data("cell");
     }
 
 
     // Cell insertion, deletion and moving.
 
 
     Notebook.prototype.delete_cell = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i >= 0 && i < this.ncells()) {
             this.cell_elements().eq(i).remove();
             if (i === (this.ncells())) {
                 this.select(i-1);
             } else {
                 this.select(i);
             };
         };
         this.dirty = true;
         return this;
     };
 
 
     Notebook.prototype.append_cell = function (cell) {
         this.element.find('div.end_space').before(cell.element);
         this.dirty = true;
         return this;
     };
 
 
     Notebook.prototype.insert_cell_below = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).after(cell.element);
         };
         this.dirty = true;
         return this
     };
 
 
     Notebook.prototype.insert_cell_above = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).before(cell.element);
         };
         this.dirty = true;
         return this;
     };
 
 
     Notebook.prototype.move_cell_up = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < this.ncells() && i > 0) {
             var pivot = this.cell_elements().eq(i-1);
             var tomove = this.cell_elements().eq(i);
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.before(tomove);
                 this.select(i-1);
             };
         };
         this.dirty = true;
         return this;
     }
 
 
     Notebook.prototype.move_cell_down = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < (this.ncells()-1) && i >= 0) {
             var pivot = this.cell_elements().eq(i+1)
             var tomove = this.cell_elements().eq(i)
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.after(tomove);
                 this.select(i+1);
             };
         };
         this.dirty = true;
         return this;
     }
 
 
     Notebook.prototype.sort_cells = function () {
         var ncells = this.ncells();
         var sindex = this.selected_index();
         var swapped;
         do {
             swapped = false
             for (var i=1; i<ncells; i++) {
                 current = this.cell_elements().eq(i).data("cell");
                 previous = this.cell_elements().eq(i-1).data("cell");
                 if (previous.input_prompt_number > current.input_prompt_number) {
                     this.move_cell_up(i);
                     swapped = true;
                 };
             };
         } while (swapped);
         this.select(sindex);
         return this;
     };
 
 
     Notebook.prototype.insert_code_cell_above = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_above(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_code_cell_below = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_below(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_html_cell_above = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.HTMLCell(this);
         cell.config_mathjax();
         this.insert_cell_above(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_html_cell_below = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.HTMLCell(this);
         cell.config_mathjax();
         this.insert_cell_below(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_markdown_cell_above = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.MarkdownCell(this);
         cell.config_mathjax();
         this.insert_cell_above(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_markdown_cell_below = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.MarkdownCell(this);
         cell.config_mathjax();
         this.insert_cell_below(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.to_code = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         if (source_cell instanceof IPython.HTMLCell || 
             source_cell instanceof IPython.MarkdownCell) {
             this.insert_code_cell_below(i);
             var target_cell = this.cells()[i+1];
             target_cell.set_code(source_cell.get_source());
             source_element.remove();
             target_cell.select();
         };
         this.dirty = true;
     };
 
 
     Notebook.prototype.to_markdown = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         var target_cell = null;
         if (source_cell instanceof IPython.CodeCell) {
             this.insert_markdown_cell_below(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
         } else if (source_cell instanceof IPython.HTMLCell) {
             this.insert_markdown_cell_below(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_source();
             if (text === source_cell.placeholder) {
                 text = target_cell.placeholder;
             }
         }
         if (target_cell !== null) {
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_source(text);
             source_element.remove();
             target_cell.edit();
         }
         this.dirty = true;
     };
 
 
     Notebook.prototype.to_html = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         var target_cell = null;
         if (source_cell instanceof IPython.CodeCell) {
             this.insert_html_cell_below(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
         } else if (source_cell instanceof IPython.MarkdownCell) {
             this.insert_html_cell_below(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_source();
             if (text === source_cell.placeholder) {
                 text = target_cell.placeholder;
             }
         }
         if (target_cell !== null) {
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_source(text);
             source_element.remove();
             target_cell.edit();
         }
         this.dirty = true;
     };
 
 
     // Cell collapsing and output clearing
 
     Notebook.prototype.collapse = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].collapse();
         this.dirty = true;
     };
 
 
     Notebook.prototype.expand = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].expand();
         this.dirty = true;
     };
 
 
     Notebook.prototype.toggle_output = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].toggle_output();
         this.dirty = true;
     };
 
 
     Notebook.prototype.set_autoindent = function (state) {
         var cells = this.cells();
         len = cells.length;
         for (var i=0; i<len; i++) {
             cells[i].set_autoindent(state)
         };
     };
 
 
     Notebook.prototype.clear_all_output = function () {
         var ncells = this.ncells();
         var cells = this.cells();
         for (var i=0; i<ncells; i++) {
             if (cells[i] instanceof IPython.CodeCell) {
                 cells[i].clear_output(true,true,true);
             }
         };
         this.dirty = true;
     };
 
     // Other cell functions: line numbers, ...
 
     Notebook.prototype.cell_toggle_line_numbers = function() {
         this.selected_cell().toggle_line_numbers()
     };
 
     // Kernel related things
 
     Notebook.prototype.start_kernel = function () {
         this.kernel = new IPython.Kernel();
         var notebook_id = IPython.save_widget.get_notebook_id();
         this.kernel.start(notebook_id, $.proxy(this.kernel_started, this));
     };
 
 
     Notebook.prototype.restart_kernel = function () {
         var that = this;
         var notebook_id = IPython.save_widget.get_notebook_id();
 
         var dialog = $('<div/>');
         dialog.html('Do you want to restart the current kernel?  You will lose all variables defined in it.');
         $(document).append(dialog);
         dialog.dialog({
             resizable: false,
             modal: true,
             title: "Restart kernel or continue running?",
             buttons : {
                 "Restart": function () {
                     that.kernel.restart($.proxy(that.kernel_started, that));
                     $(this).dialog('close');
                 },
                 "Continue running": function () {
                     $(this).dialog('close');
                 }
             }
         });
     };
 
 
     Notebook.prototype.kernel_started = function () {
         console.log("Kernel started: ", this.kernel.kernel_id);
         this.kernel.shell_channel.onmessage = $.proxy(this.handle_shell_reply,this);
         this.kernel.iopub_channel.onmessage = $.proxy(this.handle_iopub_reply,this);
     };
 
 
     Notebook.prototype.handle_shell_reply = function (e) {
         reply = $.parseJSON(e.data);
         var header = reply.header;
         var content = reply.content;
         var msg_type = header.msg_type;
         // console.log(reply);
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         if (msg_type === "execute_reply") {
             cell.set_input_prompt(content.execution_count);
             this.dirty = true;
         } else if (msg_type === "complete_reply") {
             cell.finish_completing(content.matched_text, content.matches);
         };
         var payload = content.payload || [];
         this.handle_payload(cell, payload);
     };
 
 
     Notebook.prototype.handle_payload = function (cell, payload) {
         var l = payload.length;
         for (var i=0; i<l; i++) {
             if (payload[i].source === 'IPython.zmq.page.page') {
                 if (payload[i].text.trim() !== '') {
                     IPython.pager.clear();
                     IPython.pager.expand();
                     IPython.pager.append_text(payload[i].text);
                 }
             } else if (payload[i].source === 'IPython.zmq.zmqshell.ZMQInteractiveShell.set_next_input') {
                 var index = this.find_cell_index(cell);
                 var new_cell = this.insert_code_cell_below(index);
                 new_cell.set_code(payload[i].text);
                 this.dirty = true;
             }
         };
     };
 
 
     Notebook.prototype.handle_iopub_reply = function (e) {
         reply = $.parseJSON(e.data);
         var content = reply.content;
         // console.log(reply);
         var msg_type = reply.header.msg_type;
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         var output_types = ['stream','display_data','pyout','pyerr'];
         if (output_types.indexOf(msg_type) >= 0) {
             this.handle_output(cell, msg_type, content);
         } else if (msg_type === 'status') {
             if (content.execution_state === 'busy') {
                 IPython.kernel_status_widget.status_busy();
             } else if (content.execution_state === 'idle') {
                 IPython.kernel_status_widget.status_idle();
             } else if (content.execution_state === 'dead') {
                 this.handle_status_dead();
             };
         } else if (msg_type === 'clear_output') {
             cell.clear_output(content.stdout, content.stderr, content.other);
         };
     };
 
 
     Notebook.prototype.handle_status_dead = function () {
         var that = this;
         this.kernel.stop_channels();
         var dialog = $('<div/>');
         dialog.html('The kernel has died, would you like to restart it? If you do not restart the kernel, you will be able to save the notebook, but running code will not work until the notebook is reopened.');
         $(document).append(dialog);
         dialog.dialog({
             resizable: false,
             modal: true,
             title: "Dead kernel",
             buttons : {
                 "Restart": function () {
                     that.start_kernel();
                     $(this).dialog('close');
                 },
                 "Continue running": function () {
                     $(this).dialog('close');
                 }
             }
         });
     };
 
 
     Notebook.prototype.handle_output = function (cell, msg_type, content) {
         var json = {};
         json.output_type = msg_type;
         if (msg_type === "stream") {
             json.text = utils.fixConsole(content.data);
             json.stream = content.name;
         } else if (msg_type === "display_data") {
             json = this.convert_mime_types(json, content.data);
         } else if (msg_type === "pyout") {
             json.prompt_number = content.execution_count;
             json = this.convert_mime_types(json, content.data);
         } else if (msg_type === "pyerr") {
             json.ename = content.ename;
             json.evalue = content.evalue;
             var traceback = [];
             for (var i=0; i<content.traceback.length; i++) {
                 traceback.push(utils.fixConsole(content.traceback[i]));
             }
             json.traceback = traceback;
         };
         cell.append_output(json);
         this.dirty = true;
     };
 
 
     Notebook.prototype.convert_mime_types = function (json, data) {
         if (data['text/plain'] !== undefined) {
             json.text = utils.fixConsole(data['text/plain']);
         };
         if (data['text/html'] !== undefined) {
             json.html = data['text/html'];
         };
         if (data['image/svg+xml'] !== undefined) {
             json.svg = data['image/svg+xml'];
         };
         if (data['image/png'] !== undefined) {
             json.png = data['image/png'];
         };
         if (data['image/jpeg'] !== undefined) {
             json.jpeg = data['image/jpeg'];
         };
         if (data['text/latex'] !== undefined) {
             json.latex = data['text/latex'];
         };
         if (data['application/json'] !== undefined) {
             json.json = data['application/json'];
         };
         if (data['application/javascript'] !== undefined) {
             json.javascript = data['application/javascript'];
         }
         return json;    
     };
 
 
     Notebook.prototype.execute_selected_cell = function (options) {
         // add_new: should a new cell be added if we are at the end of the nb
         // terminal: execute in terminal mode, which stays in the current cell
         default_options = {terminal: false, add_new: true}
         $.extend(default_options, options)
         var that = this;
         var cell = that.selected_cell();
         var cell_index = that.find_cell_index(cell);
         if (cell instanceof IPython.CodeCell) {
             cell.clear_output(true, true, true);
             var code = cell.get_code();
             var msg_id = that.kernel.execute(cell.get_code());
             that.msg_cell_map[msg_id] = cell.cell_id;
         } else if (cell instanceof IPython.HTMLCell) {
             cell.render();
         }
         if (default_options.terminal) {
             cell.select_all();
         } else {
             if ((cell_index === (that.ncells()-1)) && default_options.add_new) {
                 that.insert_code_cell_below();
                 // If we are adding a new cell at the end, scroll down to show it.
                 that.scroll_to_bottom();
             } else {
                 that.select(cell_index+1);
             };
         };
         this.dirty = true;
     };
 
 
     Notebook.prototype.execute_all_cells = function () {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             this.select(i);
             this.execute_selected_cell({add_new:false});
         };
         this.scroll_to_bottom();
     };
 
 
     Notebook.prototype.complete_cell = function (cell, line, cursor_pos) {
         var msg_id = this.kernel.complete(line, cursor_pos);
         this.msg_cell_map[msg_id] = cell.cell_id;
     };
 
     // Persistance and loading
 
 
     Notebook.prototype.fromJSON = function (data) {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             // Always delete cell 0 as they get renumbered as they are deleted.
             this.delete_cell(0);
         };
         // Save the metadata
         this.metadata = data.metadata;
         // Only handle 1 worksheet for now.
         var worksheet = data.worksheets[0];
         if (worksheet !== undefined) {
             var new_cells = worksheet.cells;
             ncells = new_cells.length;
             var cell_data = null;
             var new_cell = null;
             for (var i=0; i<ncells; i++) {
                 cell_data = new_cells[i];
                 if (cell_data.cell_type == 'code') {
                     new_cell = this.insert_code_cell_below();
                     new_cell.fromJSON(cell_data);
                 } else if (cell_data.cell_type === 'html') {
                     new_cell = this.insert_html_cell_below();
                     new_cell.fromJSON(cell_data);
                 } else if (cell_data.cell_type === 'markdown') {
                     new_cell = this.insert_markdown_cell_below();
                     new_cell.fromJSON(cell_data);
                 };
             };          
         };
     };
 
 
     Notebook.prototype.toJSON = function () {
         var cells = this.cells();
         var ncells = cells.length;
         cell_array = new Array(ncells);
         for (var i=0; i<ncells; i++) {
             cell_array[i] = cells[i].toJSON();
         };
         data = {
             // Only handle 1 worksheet for now.
             worksheets : [{cells:cell_array}],
             metadata : this.metadata
         }
         return data
     };
 
     Notebook.prototype.save_notebook = function () {
         if (IPython.save_widget.test_notebook_name()) {
             var notebook_id = IPython.save_widget.get_notebook_id();
             var nbname = IPython.save_widget.get_notebook_name();
             // We may want to move the name/id/nbformat logic inside toJSON?
             var data = this.toJSON();
             data.metadata.name = nbname;
             data.nbformat = 2;
             // We do the call with settings so we can set cache to false.
             var settings = {
                 processData : false,
                 cache : false,
                 type : "PUT",
                 data : JSON.stringify(data),
                 headers : {'Content-Type': 'application/json'},
                 success : $.proxy(this.notebook_saved,this),
                 error : $.proxy(this.notebook_save_failed,this)
             };
             IPython.save_widget.status_saving();
             var url = $('body').data('baseProjectUrl') + 'notebooks/' + notebook_id
             $.ajax(url, settings);
         };
     };
 
 
     Notebook.prototype.notebook_saved = function (data, status, xhr) {
         this.dirty = false;
         IPython.save_widget.notebook_saved();
         IPython.save_widget.status_save();
     }
 
 
     Notebook.prototype.notebook_save_failed = function (xhr, status, error_msg) {
         // Notify the user and reset the save button
         // TODO: Handle different types of errors (timeout etc.)
         alert('An unexpected error occured while saving the notebook.');
         IPython.save_widget.reset_status();
     }
 
 
     Notebook.prototype.load_notebook = function (callback) {
         var that = this;
         var notebook_id = IPython.save_widget.get_notebook_id();
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : function (data, status, xhr) {
                 that.notebook_loaded(data, status, xhr);
                 if (callback !== undefined) {
                     callback();
                 };
             }
         };
         IPython.save_widget.status_loading();
         var url = $('body').data('baseProjectUrl') + 'notebooks/' + notebook_id
         $.ajax(url, settings);
     }
 
 
     Notebook.prototype.notebook_loaded = function (data, status, xhr) {
+        var allowed = xhr.getResponseHeader('Allow');
+        if (allowed && allowed.indexOf('PUT') == -1){
+            this.read_only = true;
+            // unhide login button if it's relevant
+            $('span#login_widget').removeClass('hidden');
+        }else{
+            this.read_only = false;
+        }
         this.fromJSON(data);
         if (this.ncells() === 0) {
             this.insert_code_cell_below();
         };
         IPython.save_widget.status_save();
         IPython.save_widget.set_notebook_name(data.metadata.name);
-        this.start_kernel();
         this.dirty = false;
+        if (this.read_only) {
+            this.handle_read_only();
+        }else{
+            this.start_kernel();
+        }
         // fromJSON always selects the last cell inserted. We need to wait
         // until that is done before scrolling to the top.
         setTimeout(function () {
             IPython.notebook.select(0);
             IPython.notebook.scroll_to_top();
         }, 50);
     };
 
 
+    Notebook.prototype.handle_read_only = function(){
+        IPython.left_panel.collapse();
+        IPython.save_widget.element.find('button#save_notebook').addClass('hidden');
+        $('button#new_notebook').addClass('hidden');
+        $('div#cell_section').addClass('hidden');
+        $('div#kernel_section').addClass('hidden');
+    }
+
+
     IPython.Notebook = Notebook;
 
 
     return IPython;
 
 }(IPython));
 

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

@@ -1,245 +1,257 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.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // NotebookList
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var NotebookList = function (selector) {
         this.selector = selector;
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
     };
 
     NotebookList.prototype.style = function () {
         this.element.addClass('ui-widget ui-widget-content');
         $('div#project_name').addClass('ui-widget ui-widget-header');
     };
 
 
     NotebookList.prototype.bind_events = function () {
         var that = this;
         this.element.bind('dragover', function () {
             return false;
         });
         this.element.bind('drop', function (event) {
             var files = event.originalEvent.dataTransfer.files;
             for (var i = 0, f; f = files[i]; i++) {
                 var reader = new FileReader();
                 reader.readAsText(f);
                 var fname = f.name.split('.'); 
                 var nbname = fname.slice(0,-1).join('.');
                 var nbformat = fname.slice(-1)[0];
                 if (nbformat === 'ipynb') {nbformat = 'json';};
                 if (nbformat === 'py' || nbformat === 'json') {
                     var item = that.new_notebook_item(0);
                     that.add_name_input(nbname, item);
                     item.data('nbformat', nbformat);
                     // Store the notebook item in the reader so we can use it later
                     // to know which item it belongs to.
                     $(reader).data('item', item);
                     reader.onload = function (event) {
                         var nbitem = $(event.target).data('item');
                         that.add_notebook_data(event.target.result, nbitem);
                         that.add_upload_button(nbitem);
                     };
                 };
             }
             return false;
         });
     };
 
 
     NotebookList.prototype.load_list = function () {
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : $.proxy(this.list_loaded, this)
         };
         var url = $('body').data('baseProjectUrl') + 'notebooks'
         $.ajax(url, settings);
     };
 
 
     NotebookList.prototype.list_loaded = function (data, status, xhr) {
+        var allowed = xhr.getResponseHeader('Allow');
+        if (allowed && allowed.indexOf('PUT') == -1){
+            this.read_only = true;
+            $('#new_notebook').addClass('hidden');
+            // unhide login button if it's relevant
+            $('span#login_widget').removeClass('hidden');
+        }else{
+            this.read_only = false;
+        }
         var len = data.length;
         // Todo: remove old children
         for (var i=0; i<len; i++) {
             var notebook_id = data[i].notebook_id;
             var nbname = data[i].name;
             var item = this.new_notebook_item(i);
             this.add_link(notebook_id, nbname, item);
+            if (!this.read_only){
+                // hide delete buttons when readonly
             this.add_delete_button(item);
+            }
         };
     };
 
 
     NotebookList.prototype.new_notebook_item = function (index) {
         var item = $('<div/>');
         item.addClass('notebook_item ui-widget ui-widget-content ui-helper-clearfix');
         var item_name = $('<span/>').addClass('item_name');
 
         item.append(item_name);
         if (index === -1) {
             this.element.append(item);
         } else {
             this.element.children().eq(index).after(item);
         }
         return item;
     };
 
 
     NotebookList.prototype.add_link = function (notebook_id, nbname, item) {
         item.data('nbname', nbname);
         item.data('notebook_id', notebook_id);
         var new_item_name = $('<span/>').addClass('item_name');
         new_item_name.append(
             $('<a/>').
             attr('href', $('body').data('baseProjectURL')+notebook_id).
             attr('target','_blank').
             text(nbname)
         );
         var e = item.find('.item_name');
         if (e.length === 0) {
             item.append(new_item_name);
         } else {
             e.replaceWith(new_item_name);
         };
     };
 
 
     NotebookList.prototype.add_name_input = function (nbname, item) {
         item.data('nbname', nbname);
         var new_item_name = $('<span/>').addClass('item_name');
         new_item_name.append(
             $('<input/>').addClass('ui-widget ui-widget-content').
             attr('value', nbname).
             attr('size', '30').
             attr('type', 'text')
         );
         var e = item.find('.item_name');
         if (e.length === 0) {
             item.append(new_item_name);
         } else {
             e.replaceWith(new_item_name);
         };
     };
 
 
     NotebookList.prototype.add_notebook_data = function (data, item) {
         item.data('nbdata',data);
     };
 
 
     NotebookList.prototype.add_delete_button = function (item) {
         var new_buttons = $('<span/>').addClass('item_buttons');
         var delete_button = $('<button>Delete</button>').button().
             click(function (e) {
                 // $(this) is the button that was clicked.
                 var that = $(this);
                 // We use the nbname and notebook_id from the parent notebook_item element's
                 // data because the outer scopes values change as we iterate through the loop.
                 var parent_item = that.parents('div.notebook_item');
                 var nbname = parent_item.data('nbname');
                 var notebook_id = parent_item.data('notebook_id');
                 var dialog = $('<div/>');
                 dialog.html('Are you sure you want to permanently delete the notebook: ' + nbname + '?');
                 parent_item.append(dialog);
                 dialog.dialog({
                     resizable: false,
                     modal: true,
                     title: "Delete notebook",
                     buttons : {
                         "Delete": function () {
                             var settings = {
                                 processData : false,
                                 cache : false,
                                 type : "DELETE",
                                 dataType : "json",
                                 success : function (data, status, xhr) {
                                     parent_item.remove();
                                 }
                             };
                             var url = $('body').data('baseProjectUrl') + 'notebooks/' + notebook_id
                             $.ajax(url, settings);
                             $(this).dialog('close');
                         },
                         "Cancel": function () {
                             $(this).dialog('close');
                         }
                     }
                 });
             });
         new_buttons.append(delete_button);
         var e = item.find('.item_buttons');
         if (e.length === 0) {
             item.append(new_buttons);
         } else {
             e.replaceWith(new_buttons);
         };
     };
 
 
     NotebookList.prototype.add_upload_button = function (item) {
         var that = this;
         var new_buttons = $('<span/>').addClass('item_buttons');
         var upload_button = $('<button>Upload</button>').button().
             click(function (e) {
                 var nbname = item.find('.item_name > input').attr('value');
                 var nbformat = item.data('nbformat');
                 var nbdata = item.data('nbdata');
                 var content_type = 'text/plain';
                 if (nbformat === 'json') {
                     content_type = 'application/json';
                 } else if (nbformat === 'py') {
                     content_type = 'application/x-python';
                 };
                 var settings = {
                     processData : false,
                     cache : false,
                     type : 'POST',
                     dataType : 'json',
                     data : nbdata,
                     headers : {'Content-Type': content_type},
                     success : function (data, status, xhr) {
                         that.add_link(data, nbname, item);
                         that.add_delete_button(item);
                     }
                 };
 
                 var qs = $.param({name:nbname, format:nbformat});
                 var url = $('body').data('baseProjectUrl') + 'notebooks?' + qs
                 $.ajax(url, settings);
             });
         var cancel_button = $('<button>Cancel</button>').button().
             click(function (e) {
                 item.remove();
             });
         upload_button.addClass('upload_button');
         new_buttons.append(upload_button).append(cancel_button);
         var e = item.find('.item_buttons');
         if (e.length === 0) {
             item.append(new_buttons);
         } else {
             e.replaceWith(new_buttons);
         };
     };
 
 
     IPython.NotebookList = NotebookList;
 
     return IPython;
 
 }(IPython));
 

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

@@ -1,59 +1,60 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 () {
 
     MathJax.Hub.Config({
         tex2jax: {
             inlineMath: [ ['$','$'], ["\\(","\\)"] ],
             displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
         },
         displayAlign: 'left', // Change this to 'center' to center equations.
         "HTML-CSS": {
             styles: {'.MathJax_Display': {"margin": 0}}
         }
     });
     IPython.markdown_converter = new Markdown.Converter();
 
     $('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');
     $('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();
         },100);
     });
 
 });
 

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

@@ -1,39 +1,40 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 () {
 
     $('div#header').addClass('border-box-sizing');
     $('div#header_border').addClass('border-box-sizing ui-widget ui-widget-content');
 
     $('div#main_app').addClass('border-box-sizing ui-widget');
     $('div#app_hbox').addClass('hbox');
 
     $('div#content_toolbar').addClass('ui-widget ui-helper-clearfix');    
 
     $('#new_notebook').button().click(function (e) {
         window.open($('body').data('baseProjectUrl')+'new');
     });
 
     $('div#left_panel').addClass('box-flex');
     $('div#right_panel').addClass('box-flex');
 
     IPython.notebook_list = new IPython.NotebookList('div#notebook_list');
+    IPython.login_widget = new IPython.LoginWidget('span#login_widget');
     IPython.notebook_list.load_list();
 
     // These have display: none in the css file and are made visible here to prevent FLOUC.
     $('div#header').css('display','block');
     $('div#main_app').css('display','block');
 
 
 });
 

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

@@ -1,270 +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
+            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.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.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.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,290 +1,294 b''
 <!DOCTYPE HTML>
 <html>
 
 <head>
     <meta charset="utf-8">
 
     <title>IPython Notebook</title>
 
     <!-- <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') {
         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>
 
     <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" />
 
 
 </head>
 
 <body onload='CheckMathJax();'
     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" class="hidden">
+      <button id="login">Login</button>
+    </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>
     <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>

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

@@ -1,63 +1,67 b''
 <!DOCTYPE HTML>
 <html>
 
 <head>
     <meta charset="utf-8">
 
     <title>IPython Dashboard</title>
 
     <link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/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/projectdashboard.css" type="text/css" />
 
 </head>
 
 <body data-project={{project}} 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="login_widget" class="hidden">
+      <button id="login">Login</button>
+    </span>
 </div>
 
 <div id="header_border"></div>
 
 <div id="main_app">
 
     <div id="app_hbox">
 
     <div id="left_panel">
     </div>
 
     <div id="content_panel">
         <div id="content_toolbar">
             <span id="drag_info">Drag files onto the list to import notebooks.</span>
             <span id="notebooks_buttons">
                 <button id="new_notebook">New Notebook</button>
             </span>
         </div>
         <div id="notebook_list">
             <div id="project_name"><h2>{{project}}</h2></div>
         </div>
 
     </div>
 
     <div id="right_panel">
     </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/js/namespace.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/notebooklist.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/projectdashboardmain.js" type="text/javascript" charset="utf-8"></script>
 
 </body>
 
 </html>