Fixes to terminal mode execution (ctrl-enter).

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

@@ -1,313 +1,312
 
 //============================================================================
 // 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;
         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');
         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,
             enterMode : 'flat',
             tabMode: 'shift',
             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) {
             // Always ignore shift-enter in CodeMirror as we handle it.
             return true;
         // } else if (event.keyCode == 32 && (event.ctrlKey || event.metaKey) && !event.altKey) {
         } else if (event.keyCode == 9) {
             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 (this.is_completing && this.completion_cursor !== editor.getCursor()) {
                 this.is_completing = false;
                 this.completion_cursor = null;
-                console.log("Stopped completing early");
             }
             return false;
         };
     };
 
 
     CodeCell.prototype.finish_completing = function (matched_text, matches) {
         if (!this.is_completing || matches.length === 0) {return;}
         // console.log("Got matches", matched_text, matches);
 
         var that = this;
         var cur = this.completion_cursor;
         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 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}
             );
         };
 
         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 simple exit completion.
                 event.stopPropagation();
                 event.preventDefault();
                 close();
                 that.code_mirror.focus();
             }
         });
         // Double click also causes a pick.
         select.dblclick(pick);
         select.focus();
     };
 
 
     CodeCell.prototype.select = function () {
         IPython.Cell.prototype.select.apply(this);
         this.code_mirror.focus();
     };
 
 
     CodeCell.prototype.append_pyout = function (data, n) {
         var toinsert = $("<div/>").addClass("output_area output_pyout hbox");
         toinsert.append($('<div/>').
             addClass('prompt output_prompt').
             html('Out[' + n + ']:')
         );
         this.append_display_data(data, toinsert);
         toinsert.children().last().addClass("box_flex1");
         this.element.find("div.output").append(toinsert);
         // If we just output latex, typeset it.
         if (data["text/latex"] !== undefined) {
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
         };
     };
 
 
     CodeCell.prototype.append_pyerr = function (ename, evalue, tb) {
         var s = '';
         var len = tb.length;
         for (var i=0; i<len; i++) {
             s = s + tb[i] + '\n';
         }
         s = s + '\n';
         this.append_stream(s);
     };
 
 
     CodeCell.prototype.append_display_data = function (data, element) {
         if (data["text/latex"] !== undefined) {
             this.append_latex(data["text/latex"], element);
             // If it is undefined, then we just appended to div.output, which
             // makes the latex visible and we can typeset it. The typesetting
             // has to be done after the latex is on the page.
             if (element === undefined) {
                 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
             };
         } else if (data["image/svg+xml"] !== undefined) {
             this.append_svg(data["image/svg+xml"], element);
         } else if (data["image/png"] !== undefined) {
             this.append_png(data["image/png"], element);
         } else if (data["text/plain"] !== undefined) {
             this.append_stream(data["text/plain"], element);
         };
         return element;
     };
 
 
     CodeCell.prototype.append_stream = function (data, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_area output_stream");
         toinsert.append($("<pre/>").html(utils.fixConsole(data)));
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_svg = function (svg, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_area output_svg");
         toinsert.append(svg);
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_png = function (png, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_area output_png");
         toinsert.append($("<img/>").attr('src','data:image/png;base64,'+png));
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_latex = function (latex, element) {
         // This method cannot do the typesetting because the latex first has to
         // be on the page.
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_area output_latex");
         toinsert.append(latex);
         element.append(toinsert);
         return element;
     }
 
 
     CodeCell.prototype.clear_output = function () {
         this.element.find("div.output").html("");
     };
 
 
     CodeCell.prototype.clear_input = function () {
         this.code_mirror.setValue('');
     };
 
 
     CodeCell.prototype.collapse = function () {
         this.element.find('div.output').hide();
     };
 
 
     CodeCell.prototype.expand = function () {
         this.element.find('div.output').show();
     };
 
 
     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) {
         if (data.cell_type === 'code') {
             this.set_code(data.code);
             this.set_input_prompt(data.prompt_number);
         };
     };
 
 
     CodeCell.prototype.toJSON = function () {
         return {
             code : this.get_code(),
             cell_type : 'code',
             prompt_number : this.input_prompt_number
         };
     };
 
     IPython.CodeCell = CodeCell;
 
     return IPython;
 }(IPython));
 

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

@@ -1,618 +1,624
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Notebook = function (selector) {
         this.element = $(selector);
         this.element.scroll();
         this.element.data("notebook", this);
         this.next_prompt_number = 1;
         this.kernel = null;
         this.msg_cell_map = {};
         this.filename = null;
         this.notebook_load_re = /%notebook load/
         this.notebook_save_re = /%notebook save/
         this.notebook_filename_re = /(\w)+.ipynb/
         this.style();
         this.create_elements();
         this.bind_events();
         this.start_kernel();
     };
 
 
     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.
         this.element.append($('<div class="end_space"></div>').height(50));
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
             // console.log(event);
             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(true);
+                that.execute_selected_cell();
                 return false;
             } else if (event.which === 13 && event.ctrlKey) {
-                that.execute_selected_cell(false);
-                that.selected_cell().clear_input();
+                that.execute_selected_cell({terminal:true});
                 return false;
             };
         });
 
         this.element.bind('collapse_pager', function () {
             var app_height = $('div#notebook_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#notebook_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');
         });
     };
 
 
     Notebook.prototype.scroll_to_bottom = function () {
         this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 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();
             if (index === (this.ncells()-1)) {
                 this.scroll_to_bottom();
             };
         };
         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);
             };
         };
         return this;
     };
 
 
     Notebook.prototype.append_cell = function (cell) {
         this.element.find('div.end_space').before(cell.element);
         return this;
     };
 
 
     Notebook.prototype.insert_cell_after = 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);
         };
         return this
     };
 
 
     Notebook.prototype.insert_cell_before = 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);
         };
         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);
             };
         };
         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);
             };
         };
         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_before = 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.next_prompt_number);
         cell.set_input_prompt();
         this.next_prompt_number = this.next_prompt_number + 1;
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return this;
     }
 
 
     Notebook.prototype.insert_code_cell_after = 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.next_prompt_number);
         cell.set_input_prompt();
         this.next_prompt_number = this.next_prompt_number + 1;
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return this;
     }
 
 
     Notebook.prototype.insert_text_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.TextCell(this);
         cell.config_mathjax();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return this;
     }
 
 
     Notebook.prototype.insert_text_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.TextCell(this);
         cell.config_mathjax();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return this;
     }
 
 
     Notebook.prototype.text_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.TextCell) {
             this.insert_code_cell_after(i);
             var target_cell = this.cells()[i+1];
             target_cell.set_code(source_cell.get_text());
             source_element.remove();
         };
     };
 
 
     Notebook.prototype.code_to_text = 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.CodeCell) {
             this.insert_text_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_text(text);
             source_element.remove();
             target_cell.edit();
         };
     };
 
 
     // Cell collapsing
 
     Notebook.prototype.collapse = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].collapse();
     };
 
 
     Notebook.prototype.expand = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].expand();
     };
 
 
     // Kernel related things
 
     Notebook.prototype.start_kernel = function () {
         this.kernel = new IPython.Kernel();
         this.kernel.start_kernel($.proxy(this.kernel_started, 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);
         } else if (msg_type === "complete_reply") {
             cell.finish_completing(content.matched_text, content.matches);
         };
         var payload = content.payload || [];
         this.handle_payload(payload);
     };
 
 
     Notebook.prototype.handle_payload = function (payload) {
         var l = payload.length;
         if (l > 0) {
             IPython.pager.clear();
             IPython.pager.expand();
         };
         for (var i=0; i<l; i++) {
             IPython.pager.append_text(payload[i].text);
         };
     };
 
 
     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);
         if (msg_type === "stream") {
             cell.expand();
             cell.append_stream(content.data + "\n");
         } else if (msg_type === "display_data") {
             cell.expand();
             cell.append_display_data(content.data);
         } else if (msg_type === "pyout") {
             cell.expand();
             cell.append_pyout(content.data, content.execution_count)
         } else if (msg_type === "pyerr") {
             cell.expand();
             cell.append_pyerr(content.ename, content.evalue, content.traceback);
         } 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();
             };
         }
     };
 
 
     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.execute_selected_cell = function (add_new) {
-        if (add_new === undefined) {add_new = true;};
+    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);
         // TODO: the logic here needs to be moved into appropriate
         // methods of Notebook.
         if (cell instanceof IPython.CodeCell) {
             cell.clear_output();
             var code = cell.get_code();
             if (that.notebook_load_re.test(code)) {
                 var code_parts = code.split(' ');
                 if (code_parts.length === 3) {
                     that.load_notebook(code_parts[2]);
                 };
             } else if (that.notebook_save_re.test(code)) {
                 var code_parts = code.split(' ');
                 if (code_parts.length === 3) {
                     that.save_notebook(code_parts[2]);
                 } else {
                     that.save_notebook()
                 };
             } else {
                 var msg_id = that.kernel.execute(cell.get_code());
                 that.msg_cell_map[msg_id] = cell.cell_id;
             };
         } else if (cell instanceof IPython.TextCell) {
             cell.render();
         }
-        if ((cell_index === (that.ncells()-1)) && add_new) {
-            that.insert_code_cell_after();
-            // If we are adding a new cell at the end, scroll down to show it.
-            that.scroll_to_bottom();
+        if (default_options.terminal) {
+            cell.clear_input();
         } else {
-            that.select(cell_index+1);
+            if ((cell_index === (that.ncells()-1)) && default_options.add_new) {
+                that.insert_code_cell_after();
+                // 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);
+            };
         };
     };
 
 
     Notebook.prototype.execute_all_cells = function () {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             this.select(i);
-            this.execute_selected_cell(false);
+            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);
         };
         var new_cells = data.cells;
         ncells = new_cells.length;
         var cell_data = null;
         for (var i=0; i<ncells; i++) {
             cell_data = new_cells[i];
             if (cell_data.cell_type == 'code') {
                 this.insert_code_cell_after();
                 this.selected_cell().fromJSON(cell_data);
             } else if (cell_data.cell_type === 'text') {
                 this.insert_text_cell_after();
                 this.selected_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();
         };
         json = {
             cells : cell_array
         };
         return json
     };
 
 
     Notebook.prototype.test_filename = function (filename) {
         if (this.notebook_filename_re.test(filename)) {
             return true;
         } else {
             var bad_filename = $('<div/>');
             bad_filename.html(
                 "The filename you entered (" + filename + ") is not valid. Notebook filenames must have the following form: foo.ipynb"
             );
             bad_filename.dialog({title: 'Invalid filename', modal: true});
             return false;
         };
     };
 
     Notebook.prototype.save_notebook = function (filename) {
         this.filename = filename || this.filename || '';
         if (this.filename === '') {
             var no_filename = $('<div/>');
             no_filename.html(
                 "This notebook has no filename, please specify a filename of the form: foo.ipynb"
             );
             no_filename.dialog({title: 'Missing filename', modal: true});
             return;
         }
         if (!this.test_filename(this.filename)) {return;}
         var thedata = this.toJSON();
         var settings = {
           processData : false,
           cache : false,
           type : "PUT",
           data : JSON.stringify(thedata),
           success : function (data, status, xhr) {console.log(data);}
         };
         $.ajax("/notebooks/" + this.filename, settings);
     };
 
 
     Notebook.prototype.load_notebook = function (filename) {
         if (!this.test_filename(filename)) {return;}
         var that = this;
         // 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.fromJSON(data);
               that.filename = filename;
               that.kernel.restart();
           }
         };
         $.ajax("/notebooks/" + filename, settings);
     }
 
     IPython.Notebook = Notebook;
 
     return IPython;
 
 }(IPython));