notebook.js
2077 lines
| 70.2 KiB
| application/javascript
|
JavascriptLexer
|
r4609 | //---------------------------------------------------------------------------- | ||
// 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. | ||||
//---------------------------------------------------------------------------- | ||||
|
r4315 | |||
|
r4299 | //============================================================================ | ||
|
r4292 | // Notebook | ||
//============================================================================ | ||||
|
r4352 | var IPython = (function (IPython) { | ||
|
r12103 | "use strict"; | ||
|
r4352 | |||
|
r4356 | var utils = IPython.utils; | ||
|
r7139 | var key = IPython.utils.keycodes; | ||
|
r4356 | |||
|
r10033 | /** | ||
* A notebook contains and manages cells. | ||||
* | ||||
* @class Notebook | ||||
* @constructor | ||||
* @param {String} selector A jQuery selector for the notebook's DOM element | ||||
* @param {Object} [options] A config object | ||||
*/ | ||||
|
r9505 | var Notebook = function (selector, options) { | ||
var options = options || {}; | ||||
this._baseProjectUrl = options.baseProjectUrl; | ||||
|
r4352 | this.element = $(selector); | ||
this.element.scroll(); | ||||
this.element.data("notebook", this); | ||||
this.next_prompt_number = 1; | ||||
this.kernel = null; | ||||
|
r5879 | this.clipboard = null; | ||
|
r8691 | this.undelete_backup = null; | ||
this.undelete_index = null; | ||||
this.undelete_below = false; | ||||
|
r5912 | this.paste_enabled = false; | ||
|
r10781 | this.set_dirty(false); | ||
|
r4637 | this.metadata = {}; | ||
|
r10501 | this._checkpoint_after_save = false; | ||
this.last_checkpoint = null; | ||||
|
r12050 | this.checkpoints = []; | ||
|
r10505 | this.autosave_interval = 0; | ||
this.autosave_timer = null; | ||||
|
r10507 | // autosave *at most* every two minutes | ||
this.minimum_autosave_interval = 120000; | ||||
|
r7523 | // single worksheet for now | ||
this.worksheet_metadata = {}; | ||||
|
r4645 | this.control_key_active = false; | ||
|
r6047 | this.notebook_id = null; | ||
this.notebook_name = null; | ||||
|
r7229 | this.notebook_name_blacklist_re = /[\/\\:]/; | ||
|
r6061 | this.nbformat = 3 // Increment this when changing the nbformat | ||
|
r7546 | this.nbformat_minor = 0 // Increment this when changing the nbformat | ||
|
r4357 | this.style(); | ||
|
r4364 | this.create_elements(); | ||
|
r4352 | this.bind_events(); | ||
}; | ||||
|
r4292 | |||
|
r10033 | /** | ||
* Tweak the notebook's CSS style. | ||||
* | ||||
* @method style | ||||
*/ | ||||
|
r4357 | Notebook.prototype.style = function () { | ||
|
r4363 | $('div#notebook').addClass('border-box-sizing'); | ||
|
r4357 | }; | ||
|
r10033 | /** | ||
* Get the root URL of the notebook server. | ||||
* | ||||
* @method baseProjectUrl | ||||
* @return {String} The base project URL | ||||
*/ | ||||
|
r9503 | Notebook.prototype.baseProjectUrl = function(){ | ||
return this._baseProjectUrl || $('body').data('baseProjectUrl'); | ||||
}; | ||||
|
r10033 | /** | ||
* Create an HTML and CSS representation of the notebook. | ||||
* | ||||
* @method create_elements | ||||
*/ | ||||
|
r4364 | 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. | ||||
|
r4628 | var that = this; | ||
|
r10909 | this.container = $("<div/>").addClass("container").attr("id", "notebook-container"); | ||
|
r10938 | var end_space = $('<div/>').addClass('end_space'); | ||
|
r4628 | end_space.dblclick(function (e) { | ||
var ncells = that.ncells(); | ||||
|
r5945 | that.insert_cell_below('code',ncells-1); | ||
|
r4628 | }); | ||
|
r10909 | this.element.append(this.container); | ||
this.container.append(end_space); | ||||
|
r4364 | $('div#notebook').addClass('border-box-sizing'); | ||
}; | ||||
|
r10033 | /** | ||
* Bind JavaScript events: key presses and custom IPython events. | ||||
* | ||||
* @method bind_events | ||||
*/ | ||||
|
r4352 | Notebook.prototype.bind_events = function () { | ||
var that = this; | ||||
|
r7170 | |||
|
r7168 | $([IPython.events]).on('set_next_input.Notebook', function (event, data) { | ||
var index = that.find_cell_index(data.cell); | ||||
var new_cell = that.insert_cell_below('code',index); | ||||
new_cell.set_text(data.text); | ||||
that.dirty = true; | ||||
}); | ||||
|
r7228 | $([IPython.events]).on('set_dirty.Notebook', function (event, data) { | ||
that.dirty = data.value; | ||||
}); | ||||
|
r7168 | $([IPython.events]).on('select.Cell', function (event, data) { | ||
var index = that.find_cell_index(data.cell); | ||||
|
r7170 | that.select(index); | ||
|
r7168 | }); | ||
|
r11077 | |||
$([IPython.events]).on('status_autorestarting.Kernel', function () { | ||||
IPython.dialog.modal({ | ||||
title: "Kernel Restarting", | ||||
body: "The kernel appears to have died. It will restart automatically.", | ||||
buttons: { | ||||
OK : { | ||||
class : "btn-primary" | ||||
} | ||||
} | ||||
}); | ||||
}); | ||||
|
r7168 | |||
|
r4352 | $(document).keydown(function (event) { | ||
|
r8839 | |||
// Save (CTRL+S) or (AppleKey+S) | ||||
|
r5990 | //metaKey = applekey on mac | ||
|
r8839 | if ((event.ctrlKey || event.metaKey) && event.keyCode==83) { | ||
|
r10509 | that.save_checkpoint(); | ||
|
r5990 | event.preventDefault(); | ||
|
r5991 | return false; | ||
|
r7193 | } else if (event.which === key.ESC) { | ||
|
r8839 | // Intercept escape at highest level to avoid closing | ||
|
r5389 | // websocket connection with firefox | ||
|
r10577 | IPython.pager.collapse(); | ||
|
r5389 | event.preventDefault(); | ||
|
r7723 | } else if (event.which === key.SHIFT) { | ||
// ignore shift keydown | ||||
return true; | ||||
|
r5389 | } | ||
|
r7193 | if (event.which === key.UPARROW && !event.shiftKey) { | ||
|
r5945 | var cell = that.get_selected_cell(); | ||
|
r10126 | if (cell && cell.at_top()) { | ||
|
r4352 | event.preventDefault(); | ||
that.select_prev(); | ||||
}; | ||||
|
r7193 | } else if (event.which === key.DOWNARROW && !event.shiftKey) { | ||
|
r5945 | var cell = that.get_selected_cell(); | ||
|
r10126 | if (cell && cell.at_bottom()) { | ||
|
r4352 | event.preventDefault(); | ||
that.select_next(); | ||||
}; | ||||
|
r7193 | } else if (event.which === key.ENTER && event.shiftKey) { | ||
|
r4394 | that.execute_selected_cell(); | ||
|
r4380 | return false; | ||
|
r7806 | } else if (event.which === key.ENTER && event.altKey) { | ||
|
r7910 | // Execute code cell, and insert new in place | ||
|
r7806 | that.execute_selected_cell(); | ||
|
r7910 | // Only insert a new cell, if we ended up in an already populated cell | ||
|
r7921 | if (/\S/.test(that.get_selected_cell().get_text()) == true) { | ||
|
r7910 | that.insert_cell_above('code'); | ||
} | ||||
|
r7806 | return false; | ||
|
r7193 | } else if (event.which === key.ENTER && event.ctrlKey) { | ||
|
r4394 | that.execute_selected_cell({terminal:true}); | ||
|
r4390 | return false; | ||
|
r6049 | } else if (event.which === 77 && event.ctrlKey && that.control_key_active == false) { | ||
|
r4645 | that.control_key_active = true; | ||
return false; | ||||
|
r5880 | } else if (event.which === 88 && that.control_key_active) { | ||
// Cut selected cell = x | ||||
that.cut_cell(); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 67 && that.control_key_active) { | ||||
// Copy selected cell = c | ||||
that.copy_cell(); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 86 && that.control_key_active) { | ||||
|
r8770 | // Paste below selected cell = v | ||
that.paste_cell_below(); | ||||
|
r5880 | that.control_key_active = false; | ||
return false; | ||||
|
r4645 | } 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) { | ||||
|
r4659 | // Insert code cell above selected = a | ||
|
r5945 | that.insert_cell_above('code'); | ||
|
r4645 | that.control_key_active = false; | ||
return false; | ||||
} else if (event.which === 66 && that.control_key_active) { | ||||
|
r4659 | // Insert code cell below selected = b | ||
|
r5945 | that.insert_cell_below('code'); | ||
|
r4645 | that.control_key_active = false; | ||
return false; | ||||
|
r5880 | } else if (event.which === 89 && that.control_key_active) { | ||
// To code = y | ||||
|
r4645 | 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; | ||||
|
r6027 | } else if (event.which === 84 && that.control_key_active) { | ||
|
r6248 | // To Raw = t | ||
that.to_raw(); | ||||
|
r6017 | that.control_key_active = false; | ||
return false; | ||||
|
r6019 | } else if (event.which === 49 && that.control_key_active) { | ||
// To Heading 1 = 1 | ||||
that.to_heading(undefined, 1); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 50 && that.control_key_active) { | ||||
// To Heading 2 = 2 | ||||
that.to_heading(undefined, 2); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 51 && that.control_key_active) { | ||||
// To Heading 3 = 3 | ||||
that.to_heading(undefined, 3); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 52 && that.control_key_active) { | ||||
// To Heading 4 = 4 | ||||
that.to_heading(undefined, 4); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 53 && that.control_key_active) { | ||||
// To Heading 5 = 5 | ||||
that.to_heading(undefined, 5); | ||||
that.control_key_active = false; | ||||
return false; | ||||
} else if (event.which === 54 && that.control_key_active) { | ||||
// To Heading 6 = 6 | ||||
that.to_heading(undefined, 6); | ||||
that.control_key_active = false; | ||||
return false; | ||||
|
r6027 | } else if (event.which === 79 && that.control_key_active) { | ||
// Toggle output = o | ||||
|
r7429 | if (event.shiftKey){ | ||
that.toggle_output_scroll(); | ||||
} else { | ||||
that.toggle_output(); | ||||
} | ||||
|
r4645 | that.control_key_active = false; | ||
return false; | ||||
} else if (event.which === 83 && that.control_key_active) { | ||||
// Save notebook = s | ||||
|
r10501 | that.save_checkpoint(); | ||
|
r4645 | 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; | ||||
|
r4648 | } else if (event.which === 80 && that.control_key_active) { | ||
// Select previous = p | ||||
|
r4645 | that.select_prev(); | ||
that.control_key_active = false; | ||||
return false; | ||||
|
r4648 | } else if (event.which === 78 && that.control_key_active) { | ||
// Select next = n | ||||
|
r4645 | that.select_next(); | ||
that.control_key_active = false; | ||||
return false; | ||||
|
r5026 | } else if (event.which === 76 && that.control_key_active) { | ||
// Toggle line numbers = l | ||||
that.cell_toggle_line_numbers(); | ||||
|
r4646 | that.control_key_active = false; | ||
return false; | ||||
|
r5018 | } else if (event.which === 73 && that.control_key_active) { | ||
// Interrupt kernel = i | ||||
|
r6047 | that.kernel.interrupt(); | ||
|
r5018 | that.control_key_active = false; | ||
return false; | ||||
} else if (event.which === 190 && that.control_key_active) { | ||||
// Restart kernel = . # matches qt console | ||||
|
r6047 | that.restart_kernel(); | ||
|
r5018 | that.control_key_active = false; | ||
return false; | ||||
|
r4646 | } else if (event.which === 72 && that.control_key_active) { | ||
// Show keyboard shortcuts = h | ||||
|
r5862 | IPython.quick_help.show_keyboard_shortcuts(); | ||
|
r4646 | that.control_key_active = false; | ||
return false; | ||||
|
r8691 | } else if (event.which === 90 && that.control_key_active) { | ||
|
r8693 | // Undo last cell delete = z | ||
|
r8691 | that.undelete(); | ||
that.control_key_active = false; | ||||
return false; | ||||
|
r11276 | } else if (event.which === 189 && that.control_key_active) { | ||
// Split cell = - | ||||
|
r11232 | that.split_cell(); | ||
that.control_key_active = false; | ||||
|
r11276 | return false; | ||
|
r4645 | } else if (that.control_key_active) { | ||
that.control_key_active = false; | ||||
return true; | ||||
|
r10781 | } | ||
|
r5479 | return true; | ||
|
r4352 | }); | ||
|
r10781 | |||
|
r6723 | var collapse_time = function(time){ | ||
|
r9265 | var app_height = $('#ipython-main-app').height(); // content height | ||
|
r4362 | var splitter_height = $('div#pager_splitter').outerHeight(true); | ||
var new_height = app_height - splitter_height; | ||||
|
r6723 | that.element.animate({height : new_height + 'px'}, time); | ||
} | ||||
this.element.bind('collapse_pager', function (event,extrap) { | ||||
|
r8839 | var time = (extrap != undefined) ? ((extrap.duration != undefined ) ? extrap.duration : 'fast') : 'fast'; | ||
|
r6723 | collapse_time(time); | ||
|
r4361 | }); | ||
|
r6723 | var expand_time = function(time) { | ||
|
r9265 | var app_height = $('#ipython-main-app').height(); // content height | ||
|
r4362 | var splitter_height = $('div#pager_splitter').outerHeight(true); | ||
|
r4361 | var pager_height = $('div#pager').outerHeight(true); | ||
|
r8839 | var new_height = app_height - pager_height - splitter_height; | ||
|
r6723 | that.element.animate({height : new_height + 'px'}, time); | ||
} | ||||
this.element.bind('expand_pager', function (event, extrap) { | ||||
|
r8839 | var time = (extrap != undefined) ? ((extrap.duration != undefined ) ? extrap.duration : 'fast') : 'fast'; | ||
|
r6723 | expand_time(time); | ||
|
r4361 | }); | ||
|
r11111 | |||
// Firefox 22 broke $(window).on("beforeunload") | ||||
// I'm not sure why or how. | ||||
window.onbeforeunload = function (e) { | ||||
|
r5857 | // TODO: Make killing the kernel configurable. | ||
var kill_kernel = false; | ||||
|
r4542 | if (kill_kernel) { | ||
that.kernel.kill(); | ||||
|
r4550 | } | ||
|
r11047 | // if we are autosaving, trigger an autosave on nav-away. | ||
// still warn, because if we don't the autosave may fail. | ||||
|
r11644 | if (that.dirty) { | ||
|
r11047 | if ( that.autosave_interval ) { | ||
|
r11625 | // schedule autosave in a timeout | ||
// this gives you a chance to forcefully discard changes | ||||
// by reloading the page if you *really* want to. | ||||
// the timer doesn't start until you *dismiss* the dialog. | ||||
setTimeout(function () { | ||||
if (that.dirty) { | ||||
that.save_notebook(); | ||||
} | ||||
}, 1000); | ||||
|
r11048 | return "Autosave in progress, latest changes may be lost."; | ||
} else { | ||||
return "Unsaved changes will be lost."; | ||||
|
r11047 | } | ||
|
r4542 | }; | ||
|
r5502 | // Null is the *only* return value that will make the browser not | ||
// pop up the "don't leave" dialog. | ||||
return null; | ||||
|
r11111 | }; | ||
|
r4352 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
|
r10781 | * Set the dirty flag, and trigger the set_dirty.Notebook event | ||
* | ||||
* @method set_dirty | ||||
*/ | ||||
Notebook.prototype.set_dirty = function (value) { | ||||
if (value === undefined) { | ||||
value = true; | ||||
} | ||||
if (this.dirty == value) { | ||||
return; | ||||
} | ||||
$([IPython.events]).trigger('set_dirty.Notebook', {value: value}); | ||||
}; | ||||
/** | ||||
|
r10033 | * Scroll the top of the page to a given cell. | ||
* | ||||
* @method scroll_to_cell | ||||
* @param {Number} cell_number An index of the cell to view | ||||
* @param {Number} time Animation time in milliseconds | ||||
* @return {Number} Pixel offset from the top of the container | ||||
*/ | ||||
|
r8419 | Notebook.prototype.scroll_to_cell = function (cell_number, time) { | ||
var cells = this.get_cells(); | ||||
var time = time || 0; | ||||
cell_number = Math.min(cells.length-1,cell_number); | ||||
cell_number = Math.max(0 ,cell_number); | ||||
|
r8839 | var scroll_value = cells[cell_number].element.position().top-cells[0].element.position().top ; | ||
|
r8419 | this.element.animate({scrollTop:scroll_value}, time); | ||
return scroll_value; | ||||
}; | ||||
|
r10033 | /** | ||
* Scroll to the bottom of the page. | ||||
* | ||||
* @method scroll_to_bottom | ||||
*/ | ||||
|
r4364 | Notebook.prototype.scroll_to_bottom = function () { | ||
|
r4366 | this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0); | ||
|
r4364 | }; | ||
|
r10033 | /** | ||
* Scroll to the top of the page. | ||||
* | ||||
* @method scroll_to_top | ||||
*/ | ||||
|
r4488 | Notebook.prototype.scroll_to_top = function () { | ||
this.element.animate({scrollTop:0}, 0); | ||||
}; | ||||
|
r4352 | // Cell indexing, retrieval, etc. | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get all cell elements in the notebook. | ||||
* | ||||
* @method get_cell_elements | ||||
* @return {jQuery} A selector of all cell elements | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_cell_elements = function () { | ||
|
r10909 | return this.container.children("div.cell"); | ||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get a particular cell element. | ||||
* | ||||
* @method get_cell_element | ||||
* @param {Number} index An index of a cell to select | ||||
* @return {jQuery} A selector of the given cell. | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_cell_element = function (index) { | ||
var result = null; | ||||
var e = this.get_cell_elements().eq(index); | ||||
if (e.length !== 0) { | ||||
result = e; | ||||
} | ||||
return result; | ||||
}; | ||||
|
r10033 | /** | ||
* Count the cells in this notebook. | ||||
* | ||||
* @method ncells | ||||
* @return {Number} The number of cells in this notebook | ||||
*/ | ||||
Notebook.prototype.ncells = function () { | ||||
|
r5945 | return this.get_cell_elements().length; | ||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get all Cell objects in this notebook. | ||||
* | ||||
* @method get_cells | ||||
* @return {Array} This notebook's Cell objects | ||||
*/ | ||||
|
r4352 | // TODO: we are often calling cells as cells()[i], which we should optimize | ||
// to cells(i) or a new method. | ||||
|
r5945 | Notebook.prototype.get_cells = function () { | ||
return this.get_cell_elements().toArray().map(function (e) { | ||||
|
r4352 | return $(e).data("cell"); | ||
}); | ||||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get a Cell object from this notebook. | ||||
* | ||||
* @method get_cell | ||||
* @param {Number} index An index of a cell to retrieve | ||||
* @return {Cell} A particular cell | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_cell = function (index) { | ||
var result = null; | ||||
var ce = this.get_cell_element(index); | ||||
if (ce !== null) { | ||||
result = ce.data('cell'); | ||||
} | ||||
return result; | ||||
} | ||||
|
r10033 | /** | ||
* Get the cell below a given cell. | ||||
* | ||||
* @method get_next_cell | ||||
* @param {Cell} cell The provided cell | ||||
* @return {Cell} The next cell | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_next_cell = function (cell) { | ||
var result = null; | ||||
var index = this.find_cell_index(cell); | ||||
|
r9549 | if (this.is_valid_cell_index(index+1)) { | ||
|
r5945 | result = this.get_cell(index+1); | ||
} | ||||
return result; | ||||
} | ||||
|
r10033 | /** | ||
* Get the cell above a given cell. | ||||
* | ||||
* @method get_prev_cell | ||||
* @param {Cell} cell The provided cell | ||||
* @return {Cell} The previous cell | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_prev_cell = function (cell) { | ||
|
r10033 | // TODO: off-by-one | ||
// nb.get_prev_cell(nb.get_cell(1)) is null | ||||
|
r5945 | var result = null; | ||
var index = this.find_cell_index(cell); | ||||
if (index !== null && index > 1) { | ||||
result = this.get_cell(index-1); | ||||
} | ||||
return result; | ||||
} | ||||
|
r10033 | |||
/** | ||||
* Get the numeric index of a given cell. | ||||
* | ||||
* @method find_cell_index | ||||
* @param {Cell} cell The provided cell | ||||
* @return {Number} The cell's numeric index | ||||
*/ | ||||
|
r4352 | Notebook.prototype.find_cell_index = function (cell) { | ||
var result = null; | ||||
|
r5945 | this.get_cell_elements().filter(function (index) { | ||
|
r4352 | if ($(this).data("cell") === cell) { | ||
result = index; | ||||
}; | ||||
}); | ||||
return result; | ||||
}; | ||||
|
r4292 | |||
|
r10033 | /** | ||
* Get a given index , or the selected index if none is provided. | ||||
* | ||||
* @method index_or_selected | ||||
* @param {Number} index A cell's index | ||||
* @return {Number} The given index, or selected index if none is provided. | ||||
*/ | ||||
|
r4352 | Notebook.prototype.index_or_selected = function (index) { | ||
|
r5898 | var i; | ||
|
r5945 | if (index === undefined || index === null) { | ||
i = this.get_selected_index(); | ||||
|
r5898 | if (i === null) { | ||
i = 0; | ||||
} | ||||
} else { | ||||
i = index; | ||||
} | ||||
return i; | ||||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get the currently selected cell. | ||||
* @method get_selected_cell | ||||
* @return {Cell} The selected cell | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_selected_cell = function () { | ||
var index = this.get_selected_index(); | ||||
return this.get_cell(index); | ||||
|
r4292 | }; | ||
|
r10033 | /** | ||
* Check whether a cell index is valid. | ||||
* | ||||
* @method is_valid_cell_index | ||||
* @param {Number} index A cell index | ||||
* @return True if the index is valid, false otherwise | ||||
*/ | ||||
|
r5945 | Notebook.prototype.is_valid_cell_index = function (index) { | ||
if (index !== null && index >= 0 && index < this.ncells()) { | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r4299 | }; | ||
|
r5945 | } | ||
|
r4299 | |||
|
r10033 | /** | ||
* Get the index of the currently selected cell. | ||||
* @method get_selected_index | ||||
* @return {Number} The selected cell's numeric index | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_selected_index = function () { | ||
|
r4352 | var result = null; | ||
|
r5945 | this.get_cell_elements().filter(function (index) { | ||
|
r4352 | if ($(this).data("cell").selected === true) { | ||
result = index; | ||||
}; | ||||
}); | ||||
return result; | ||||
}; | ||||
|
r4292 | |||
|
r5945 | // Cell selection. | ||
|
r4292 | |||
|
r10033 | /** | ||
* Programmatically select a cell. | ||||
* | ||||
* @method select | ||||
* @param {Number} index A cell's index | ||||
* @return {Notebook} This notebook | ||||
*/ | ||||
|
r5945 | Notebook.prototype.select = function (index) { | ||
|
r9549 | if (this.is_valid_cell_index(index)) { | ||
|
r8839 | var sindex = this.get_selected_index() | ||
|
r5946 | if (sindex !== null && index !== sindex) { | ||
|
r5945 | this.get_cell(sindex).unselect(); | ||
|
r4352 | }; | ||
|
r8839 | var cell = this.get_cell(index); | ||
|
r5994 | cell.select(); | ||
|
r6028 | if (cell.cell_type === 'heading') { | ||
|
r6047 | $([IPython.events]).trigger('selected_cell_type_changed.Notebook', | ||
{'cell_type':cell.cell_type,level:cell.level} | ||||
); | ||||
|
r6028 | } else { | ||
|
r6047 | $([IPython.events]).trigger('selected_cell_type_changed.Notebook', | ||
{'cell_type':cell.cell_type} | ||||
); | ||||
}; | ||||
|
r4352 | }; | ||
|
r4292 | return this; | ||
}; | ||||
|
r10033 | /** | ||
* Programmatically select the next cell. | ||||
* | ||||
* @method select_next | ||||
* @return {Notebook} This notebook | ||||
*/ | ||||
|
r5945 | Notebook.prototype.select_next = function () { | ||
var index = this.get_selected_index(); | ||||
|
r9549 | this.select(index+1); | ||
|
r5479 | return this; | ||
|
r4292 | }; | ||
|
r4352 | |||
|
r10033 | /** | ||
* Programmatically select the previous cell. | ||||
* | ||||
* @method select_prev | ||||
* @return {Notebook} This notebook | ||||
*/ | ||||
|
r5945 | Notebook.prototype.select_prev = function () { | ||
var index = this.get_selected_index(); | ||||
|
r9549 | this.select(index-1); | ||
|
r4352 | return this; | ||
|
r4292 | }; | ||
|
r4352 | |||
|
r5945 | // Cell movement | ||
|
r9788 | /** | ||
|
r10033 | * Move given (or selected) cell up and select it. | ||
* | ||||
|
r9788 | * @method move_cell_up | ||
* @param [index] {integer} cell index | ||||
|
r10033 | * @return {Notebook} This notebook | ||
|
r9788 | **/ | ||
|
r4352 | Notebook.prototype.move_cell_up = function (index) { | ||
|
r9788 | var i = this.index_or_selected(index); | ||
if (this.is_valid_cell_index(i) && i > 0) { | ||||
|
r5945 | var pivot = this.get_cell_element(i-1); | ||
var tomove = this.get_cell_element(i); | ||||
|
r4352 | if (pivot !== null && tomove !== null) { | ||
tomove.detach(); | ||||
pivot.before(tomove); | ||||
this.select(i-1); | ||||
|
r4292 | }; | ||
|
r10781 | this.set_dirty(true); | ||
|
r4292 | }; | ||
|
r4352 | return this; | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r9788 | /** | ||
* Move given (or selected) cell down and select it | ||||
|
r10033 | * | ||
|
r9788 | * @method move_cell_down | ||
* @param [index] {integer} cell index | ||||
|
r10033 | * @return {Notebook} This notebook | ||
|
r9788 | **/ | ||
|
r4352 | Notebook.prototype.move_cell_down = function (index) { | ||
|
r9788 | var i = this.index_or_selected(index); | ||
|
r9549 | if ( this.is_valid_cell_index(i) && this.is_valid_cell_index(i+1)) { | ||
|
r5945 | var pivot = this.get_cell_element(i+1); | ||
var tomove = this.get_cell_element(i); | ||||
|
r4352 | if (pivot !== null && tomove !== null) { | ||
tomove.detach(); | ||||
pivot.after(tomove); | ||||
this.select(i+1); | ||||
}; | ||||
}; | ||||
|
r10781 | this.set_dirty(); | ||
|
r4352 | return this; | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r5945 | // Insertion, deletion. | ||
|
r4292 | |||
|
r10033 | /** | ||
* Delete a cell from the notebook. | ||||
* | ||||
* @method delete_cell | ||||
* @param [index] A cell's numeric index | ||||
* @return {Notebook} This notebook | ||||
*/ | ||||
|
r5945 | Notebook.prototype.delete_cell = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r8691 | var cell = this.get_selected_cell(); | ||
this.undelete_backup = cell.toJSON(); | ||||
|
r11118 | $('#undelete_cell').removeClass('disabled'); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
var ce = this.get_cell_element(i); | ||||
ce.remove(); | ||||
if (i === (this.ncells())) { | ||||
this.select(i-1); | ||||
|
r8691 | this.undelete_index = i - 1; | ||
this.undelete_below = true; | ||||
|
r5945 | } else { | ||
this.select(i); | ||||
|
r8691 | this.undelete_index = i; | ||
this.undelete_below = false; | ||||
|
r5945 | }; | ||
|
r11214 | $([IPython.events]).trigger('delete.Cell', {'cell': cell, 'index': i}); | ||
|
r10781 | this.set_dirty(true); | ||
|
r5945 | }; | ||
return this; | ||||
|
r5479 | }; | ||
|
r4299 | |||
|
r9550 | /** | ||
* Insert a cell so that after insertion the cell is at given index. | ||||
* | ||||
* Similar to insert_above, but index parameter is mandatory | ||||
* | ||||
* Index will be brought back into the accissible range [0,n] | ||||
* | ||||
|
r10033 | * @method insert_cell_at_index | ||
|
r10375 | * @param type {string} in ['code','markdown','heading'] | ||
|
r9677 | * @param [index] {int} a valid index where to inser cell | ||
|
r9550 | * | ||
|
r9677 | * @return cell {cell|null} created cell or null | ||
|
r9550 | **/ | ||
Notebook.prototype.insert_cell_at_index = function(type, index){ | ||||
|
r9677 | |||
var ncells = this.ncells(); | ||||
|
r9550 | var index = Math.min(index,ncells); | ||
index = Math.max(index,0); | ||||
|
r6017 | var cell = null; | ||
|
r9550 | |||
|
r9789 | if (ncells === 0 || this.is_valid_cell_index(index) || index === ncells) { | ||
|
r5945 | if (type === 'code') { | ||
|
r7168 | cell = new IPython.CodeCell(this.kernel); | ||
|
r5945 | cell.set_input_prompt(); | ||
} else if (type === 'markdown') { | ||||
|
r7168 | cell = new IPython.MarkdownCell(); | ||
|
r6248 | } else if (type === 'raw') { | ||
|
r7168 | cell = new IPython.RawCell(); | ||
|
r6019 | } else if (type === 'heading') { | ||
|
r7168 | cell = new IPython.HeadingCell(); | ||
|
r9677 | } | ||
if(this._insert_element_at_index(cell.element,index)){ | ||||
|
r5946 | cell.render(); | ||
this.select(this.find_cell_index(cell)); | ||||
|
r11214 | $([IPython.events]).trigger('create.Cell', {'cell': cell, 'index': index}); | ||
|
r10781 | this.set_dirty(true); | ||
|
r9677 | } | ||
} | ||||
|
r6017 | return cell; | ||
|
r9550 | |||
|
r5479 | }; | ||
|
r4507 | |||
|
r9677 | /** | ||
* Insert an element at given cell index. | ||||
* | ||||
|
r10033 | * @method _insert_element_at_index | ||
|
r9677 | * @param element {dom element} a cell element | ||
* @param [index] {int} a valid index where to inser cell | ||||
* @private | ||||
* | ||||
* return true if everything whent fine. | ||||
**/ | ||||
Notebook.prototype._insert_element_at_index = function(element, index){ | ||||
|
r9788 | if (element === undefined){ | ||
|
r9688 | return false; | ||
} | ||||
|
r9677 | var ncells = this.ncells(); | ||
|
r9688 | if (ncells === 0) { | ||
// special case append if empty | ||||
this.element.find('div.end_space').before(element); | ||||
|
r9788 | } else if ( ncells === index ) { | ||
|
r9688 | // special case append it the end, but not empty | ||
this.get_cell_element(index-1).after(element); | ||||
} else if (this.is_valid_cell_index(index)) { | ||||
// otherwise always somewhere to append to | ||||
this.get_cell_element(index).before(element); | ||||
} else { | ||||
return false; | ||||
} | ||||
|
r4507 | |||
|
r8694 | if (this.undelete_index !== null && index <= this.undelete_index) { | ||
this.undelete_index = this.undelete_index + 1; | ||||
|
r10781 | this.set_dirty(true); | ||
|
r8694 | } | ||
|
r9688 | return true; | ||
|
r9550 | }; | ||
/** | ||||
* Insert a cell of given type above given index, or at top | ||||
* of notebook if index smaller than 0. | ||||
* | ||||
* default index value is the one of currently selected cell | ||||
* | ||||
|
r10033 | * @method insert_cell_above | ||
|
r9550 | * @param type {string} cell type | ||
* @param [index] {integer} | ||||
* | ||||
* @return handle to created cell or null | ||||
**/ | ||||
Notebook.prototype.insert_cell_above = function (type, index) { | ||||
index = this.index_or_selected(index); | ||||
return this.insert_cell_at_index(type, index); | ||||
|
r5479 | }; | ||
|
r4507 | |||
|
r9677 | /** | ||
* Insert a cell of given type below given index, or at bottom | ||||
* of notebook if index greater thatn number of cell | ||||
* | ||||
* default index value is the one of currently selected cell | ||||
* | ||||
* @method insert_cell_below | ||||
* @param type {string} cell type | ||||
* @param [index] {integer} | ||||
* | ||||
* @return handle to created cell or null | ||||
* | ||||
**/ | ||||
Notebook.prototype.insert_cell_below = function (type, index) { | ||||
index = this.index_or_selected(index); | ||||
return this.insert_cell_at_index(type, index+1); | ||||
}; | ||||
/** | ||||
* Insert cell at end of notebook | ||||
* | ||||
* @method insert_cell_at_bottom | ||||
|
r10033 | * @param {String} type cell type | ||
|
r9677 | * | ||
* @return the added cell; or null | ||||
**/ | ||||
Notebook.prototype.insert_cell_at_bottom = function (type){ | ||||
var len = this.ncells(); | ||||
return this.insert_cell_below(type,len-1); | ||||
}; | ||||
|
r10033 | /** | ||
* Turn a cell into a code cell. | ||||
* | ||||
* @method to_code | ||||
* @param {Number} [index] A cell's index | ||||
*/ | ||||
|
r4507 | Notebook.prototype.to_code = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
var source_element = this.get_cell_element(i); | ||||
var source_cell = source_element.data("cell"); | ||||
if (!(source_cell instanceof IPython.CodeCell)) { | ||||
|
r8839 | var target_cell = this.insert_cell_below('code',i); | ||
|
r5945 | var text = source_cell.get_text(); | ||
if (text === source_cell.placeholder) { | ||||
text = ''; | ||||
} | ||||
target_cell.set_text(text); | ||||
|
r7587 | // make this value the starting point, so that we can only undo | ||
// to this state, instead of a blank cell | ||||
target_cell.code_mirror.clearHistory(); | ||||
|
r5945 | source_element.remove(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r5945 | }; | ||
|
r4352 | }; | ||
}; | ||||
|
r4299 | |||
|
r10033 | /** | ||
* Turn a cell into a Markdown cell. | ||||
* | ||||
* @method to_markdown | ||||
* @param {Number} [index] A cell's index | ||||
*/ | ||||
|
r4508 | Notebook.prototype.to_markdown = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
var source_element = this.get_cell_element(i); | ||||
var source_cell = source_element.data("cell"); | ||||
if (!(source_cell instanceof IPython.MarkdownCell)) { | ||||
|
r8839 | var target_cell = this.insert_cell_below('markdown',i); | ||
|
r5945 | var text = source_cell.get_text(); | ||
if (text === source_cell.placeholder) { | ||||
|
r5946 | text = ''; | ||
|
r5945 | }; | ||
|
r6017 | // The edit must come before the set_text. | ||
target_cell.edit(); | ||||
target_cell.set_text(text); | ||||
|
r7587 | // make this value the starting point, so that we can only undo | ||
// to this state, instead of a blank cell | ||||
target_cell.code_mirror.clearHistory(); | ||||
|
r6017 | source_element.remove(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r5944 | }; | ||
}; | ||||
|
r4507 | }; | ||
|
r10033 | /** | ||
* Turn a cell into a raw text cell. | ||||
* | ||||
* @method to_raw | ||||
* @param {Number} [index] A cell's index | ||||
*/ | ||||
|
r6248 | Notebook.prototype.to_raw = function (index) { | ||
|
r6017 | var i = this.index_or_selected(index); | ||
if (this.is_valid_cell_index(i)) { | ||||
var source_element = this.get_cell_element(i); | ||||
var source_cell = source_element.data("cell"); | ||||
var target_cell = null; | ||||
|
r6248 | if (!(source_cell instanceof IPython.RawCell)) { | ||
target_cell = this.insert_cell_below('raw',i); | ||||
|
r6017 | var text = source_cell.get_text(); | ||
if (text === source_cell.placeholder) { | ||||
text = ''; | ||||
}; | ||||
// The edit must come before the set_text. | ||||
target_cell.edit(); | ||||
target_cell.set_text(text); | ||||
|
r7587 | // make this value the starting point, so that we can only undo | ||
// to this state, instead of a blank cell | ||||
target_cell.code_mirror.clearHistory(); | ||||
|
r6017 | source_element.remove(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r6017 | }; | ||
}; | ||||
}; | ||||
|
r10033 | /** | ||
* Turn a cell into a heading cell. | ||||
* | ||||
* @method to_heading | ||||
* @param {Number} [index] A cell's index | ||||
* @param {Number} [level] A heading level (e.g., 1 becomes <h1>) | ||||
*/ | ||||
|
r6019 | Notebook.prototype.to_heading = function (index, level) { | ||
level = level || 1; | ||||
var i = this.index_or_selected(index); | ||||
if (this.is_valid_cell_index(i)) { | ||||
var source_element = this.get_cell_element(i); | ||||
var source_cell = source_element.data("cell"); | ||||
var target_cell = null; | ||||
if (source_cell instanceof IPython.HeadingCell) { | ||||
source_cell.set_level(level); | ||||
} else { | ||||
target_cell = this.insert_cell_below('heading',i); | ||||
var text = source_cell.get_text(); | ||||
if (text === source_cell.placeholder) { | ||||
text = ''; | ||||
}; | ||||
// The edit must come before the set_text. | ||||
target_cell.set_level(level); | ||||
target_cell.edit(); | ||||
target_cell.set_text(text); | ||||
|
r7587 | // make this value the starting point, so that we can only undo | ||
// to this state, instead of a blank cell | ||||
target_cell.code_mirror.clearHistory(); | ||||
|
r6019 | source_element.remove(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r6019 | }; | ||
|
r6047 | $([IPython.events]).trigger('selected_cell_type_changed.Notebook', | ||
{'cell_type':'heading',level:level} | ||||
); | ||||
|
r6019 | }; | ||
}; | ||||
|
r5945 | // Cut/Copy/Paste | ||
|
r5879 | |||
|
r10033 | /** | ||
* Enable UI elements for pasting cells. | ||||
* | ||||
* @method enable_paste | ||||
*/ | ||||
|
r5879 | Notebook.prototype.enable_paste = function () { | ||
var that = this; | ||||
|
r5912 | if (!this.paste_enabled) { | ||
|
r11118 | $('#paste_cell_replace').removeClass('disabled') | ||
|
r8715 | .on('click', function () {that.paste_cell_replace();}); | ||
|
r11118 | $('#paste_cell_above').removeClass('disabled') | ||
|
r5912 | .on('click', function () {that.paste_cell_above();}); | ||
|
r11118 | $('#paste_cell_below').removeClass('disabled') | ||
|
r5912 | .on('click', function () {that.paste_cell_below();}); | ||
this.paste_enabled = true; | ||||
}; | ||||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Disable UI elements for pasting cells. | ||||
* | ||||
* @method disable_paste | ||||
*/ | ||||
|
r5879 | Notebook.prototype.disable_paste = function () { | ||
|
r5912 | if (this.paste_enabled) { | ||
|
r11118 | $('#paste_cell_replace').addClass('disabled').off('click'); | ||
$('#paste_cell_above').addClass('disabled').off('click'); | ||||
$('#paste_cell_below').addClass('disabled').off('click'); | ||||
|
r5912 | this.paste_enabled = false; | ||
}; | ||||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Cut a cell. | ||||
* | ||||
* @method cut_cell | ||||
*/ | ||||
|
r5879 | Notebook.prototype.cut_cell = function () { | ||
this.copy_cell(); | ||||
this.delete_cell(); | ||||
} | ||||
|
r10033 | /** | ||
* Copy a cell. | ||||
* | ||||
* @method copy_cell | ||||
*/ | ||||
|
r5879 | Notebook.prototype.copy_cell = function () { | ||
|
r5945 | var cell = this.get_selected_cell(); | ||
|
r5879 | this.clipboard = cell.toJSON(); | ||
this.enable_paste(); | ||||
}; | ||||
|
r10033 | /** | ||
* Replace the selected cell with a cell in the clipboard. | ||||
* | ||||
* @method paste_cell_replace | ||||
*/ | ||||
|
r8715 | Notebook.prototype.paste_cell_replace = function () { | ||
|
r5912 | if (this.clipboard !== null && this.paste_enabled) { | ||
|
r5879 | var cell_data = this.clipboard; | ||
|
r5945 | var new_cell = this.insert_cell_above(cell_data.cell_type); | ||
|
r5944 | new_cell.fromJSON(cell_data); | ||
|
r8839 | var old_cell = this.get_next_cell(new_cell); | ||
|
r5945 | this.delete_cell(this.find_cell_index(old_cell)); | ||
this.select(this.find_cell_index(new_cell)); | ||||
|
r5879 | }; | ||
}; | ||||
|
r10033 | /** | ||
* Paste a cell from the clipboard above the selected cell. | ||||
* | ||||
* @method paste_cell_above | ||||
*/ | ||||
|
r5879 | Notebook.prototype.paste_cell_above = function () { | ||
|
r5912 | if (this.clipboard !== null && this.paste_enabled) { | ||
|
r5879 | var cell_data = this.clipboard; | ||
|
r5945 | var new_cell = this.insert_cell_above(cell_data.cell_type); | ||
|
r5944 | new_cell.fromJSON(cell_data); | ||
|
r5879 | }; | ||
}; | ||||
|
r10033 | /** | ||
* Paste a cell from the clipboard below the selected cell. | ||||
* | ||||
* @method paste_cell_below | ||||
*/ | ||||
|
r5879 | Notebook.prototype.paste_cell_below = function () { | ||
|
r5912 | if (this.clipboard !== null && this.paste_enabled) { | ||
|
r5879 | var cell_data = this.clipboard; | ||
|
r5945 | var new_cell = this.insert_cell_below(cell_data.cell_type); | ||
|
r5944 | new_cell.fromJSON(cell_data); | ||
|
r5879 | }; | ||
}; | ||||
|
r8691 | // Cell undelete | ||
|
r10033 | /** | ||
* Restore the most recently deleted cell. | ||||
* | ||||
* @method undelete | ||||
*/ | ||||
|
r8691 | Notebook.prototype.undelete = function() { | ||
if (this.undelete_backup !== null && this.undelete_index !== null) { | ||||
var current_index = this.get_selected_index(); | ||||
if (this.undelete_index < current_index) { | ||||
current_index = current_index + 1; | ||||
} | ||||
if (this.undelete_index >= this.ncells()) { | ||||
this.select(this.ncells() - 1); | ||||
} | ||||
else { | ||||
this.select(this.undelete_index); | ||||
} | ||||
var cell_data = this.undelete_backup; | ||||
var new_cell = null; | ||||
if (this.undelete_below) { | ||||
new_cell = this.insert_cell_below(cell_data.cell_type); | ||||
} else { | ||||
new_cell = this.insert_cell_above(cell_data.cell_type); | ||||
} | ||||
new_cell.fromJSON(cell_data); | ||||
this.select(current_index); | ||||
this.undelete_backup = null; | ||||
this.undelete_index = null; | ||||
} | ||||
|
r11118 | $('#undelete_cell').addClass('disabled'); | ||
|
r8691 | } | ||
|
r5879 | |||
|
r5945 | // Split/merge | ||
|
r10033 | /** | ||
* Split the selected cell into two, at the cursor. | ||||
* | ||||
* @method split_cell | ||||
*/ | ||||
|
r5897 | Notebook.prototype.split_cell = function () { | ||
|
r5898 | // Todo: implement spliting for other cell types. | ||
|
r5945 | var cell = this.get_selected_cell(); | ||
|
r5946 | if (cell.is_splittable()) { | ||
|
r8839 | var texta = cell.get_pre_cursor(); | ||
var textb = cell.get_post_cursor(); | ||||
|
r5946 | if (cell instanceof IPython.CodeCell) { | ||
cell.set_text(texta); | ||||
var new_cell = this.insert_cell_below('code'); | ||||
new_cell.set_text(textb); | ||||
} else if (cell instanceof IPython.MarkdownCell) { | ||||
cell.set_text(texta); | ||||
cell.render(); | ||||
var new_cell = this.insert_cell_below('markdown'); | ||||
new_cell.edit(); // editor must be visible to call set_text | ||||
new_cell.set_text(textb); | ||||
new_cell.render(); | ||||
|
r10375 | } | ||
|
r5897 | }; | ||
}; | ||||
|
r10033 | /** | ||
* Combine the selected cell into the cell above it. | ||||
* | ||||
* @method merge_cell_above | ||||
*/ | ||||
|
r5898 | Notebook.prototype.merge_cell_above = function () { | ||
|
r5945 | var index = this.get_selected_index(); | ||
|
r5946 | var cell = this.get_cell(index); | ||
|
r12509 | if (!cell.is_mergeable()) { | ||
return; | ||||
} | ||||
|
r5898 | if (index > 0) { | ||
|
r8839 | var upper_cell = this.get_cell(index-1); | ||
|
r12509 | if (!upper_cell.is_mergeable()) { | ||
return; | ||||
} | ||||
|
r8839 | var upper_text = upper_cell.get_text(); | ||
var text = cell.get_text(); | ||||
|
r5946 | if (cell instanceof IPython.CodeCell) { | ||
cell.set_text(upper_text+'\n'+text); | ||||
|
r10375 | } else if (cell instanceof IPython.MarkdownCell) { | ||
|
r5946 | cell.edit(); | ||
cell.set_text(upper_text+'\n'+text); | ||||
cell.render(); | ||||
|
r5898 | }; | ||
|
r5946 | this.delete_cell(index-1); | ||
this.select(this.find_cell_index(cell)); | ||||
|
r5898 | }; | ||
}; | ||||
|
r10033 | /** | ||
* Combine the selected cell into the cell below it. | ||||
* | ||||
* @method merge_cell_below | ||||
*/ | ||||
|
r5898 | Notebook.prototype.merge_cell_below = function () { | ||
|
r5945 | var index = this.get_selected_index(); | ||
|
r5946 | var cell = this.get_cell(index); | ||
|
r12509 | if (!cell.is_mergeable()) { | ||
return; | ||||
} | ||||
|
r5898 | if (index < this.ncells()-1) { | ||
|
r8839 | var lower_cell = this.get_cell(index+1); | ||
|
r12509 | if (!lower_cell.is_mergeable()) { | ||
return; | ||||
} | ||||
|
r8839 | var lower_text = lower_cell.get_text(); | ||
var text = cell.get_text(); | ||||
|
r5946 | if (cell instanceof IPython.CodeCell) { | ||
cell.set_text(text+'\n'+lower_text); | ||||
|
r10375 | } else if (cell instanceof IPython.MarkdownCell) { | ||
|
r5946 | cell.edit(); | ||
cell.set_text(text+'\n'+lower_text); | ||||
cell.render(); | ||||
|
r5898 | }; | ||
|
r5946 | this.delete_cell(index+1); | ||
this.select(this.find_cell_index(cell)); | ||||
|
r5898 | }; | ||
}; | ||||
|
r5959 | |||
|
r4543 | // Cell collapsing and output clearing | ||
|
r4352 | |||
|
r10033 | /** | ||
* Hide a cell's output. | ||||
* | ||||
* @method collapse | ||||
* @param {Number} index A cell's numeric index | ||||
*/ | ||||
|
r4352 | Notebook.prototype.collapse = function (index) { | ||
var i = this.index_or_selected(index); | ||||
|
r5945 | this.get_cell(i).collapse(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r4299 | }; | ||
|
r10033 | /** | ||
* Show a cell's output. | ||||
* | ||||
* @method expand | ||||
* @param {Number} index A cell's numeric index | ||||
*/ | ||||
|
r4352 | Notebook.prototype.expand = function (index) { | ||
var i = this.index_or_selected(index); | ||||
|
r5945 | this.get_cell(i).expand(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r4352 | }; | ||
|
r10033 | /** Toggle whether a cell's output is collapsed or expanded. | ||
* | ||||
* @method toggle_output | ||||
* @param {Number} index A cell's numeric index | ||||
*/ | ||||
|
r4639 | Notebook.prototype.toggle_output = function (index) { | ||
var i = this.index_or_selected(index); | ||||
|
r5945 | this.get_cell(i).toggle_output(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r4639 | }; | ||
|
r10033 | /** | ||
* Toggle a scrollbar for long cell outputs. | ||||
* | ||||
* @method toggle_output_scroll | ||||
* @param {Number} index A cell's numeric index | ||||
*/ | ||||
|
r7429 | Notebook.prototype.toggle_output_scroll = function (index) { | ||
var i = this.index_or_selected(index); | ||||
this.get_cell(i).toggle_output_scroll(); | ||||
}; | ||||
|
r10033 | /** | ||
* Hide each code cell's output area. | ||||
* | ||||
* @method collapse_all_output | ||||
*/ | ||||
|
r7362 | Notebook.prototype.collapse_all_output = function () { | ||
var ncells = this.ncells(); | ||||
var cells = this.get_cells(); | ||||
for (var i=0; i<ncells; i++) { | ||||
if (cells[i] instanceof IPython.CodeCell) { | ||||
cells[i].output_area.collapse(); | ||||
} | ||||
}; | ||||
// this should not be set if the `collapse` key is removed from nbformat | ||||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r10033 | /** | ||
* Expand each code cell's output area, and add a scrollbar for long output. | ||||
* | ||||
* @method scroll_all_output | ||||
*/ | ||||
|
r7362 | Notebook.prototype.scroll_all_output = function () { | ||
var ncells = this.ncells(); | ||||
var cells = this.get_cells(); | ||||
for (var i=0; i<ncells; i++) { | ||||
if (cells[i] instanceof IPython.CodeCell) { | ||||
cells[i].output_area.expand(); | ||||
|
r10776 | cells[i].output_area.scroll_if_long(); | ||
|
r7362 | } | ||
}; | ||||
// this should not be set if the `collapse` key is removed from nbformat | ||||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r10033 | /** | ||
* Expand each code cell's output area, and remove scrollbars. | ||||
* | ||||
* @method expand_all_output | ||||
*/ | ||||
|
r7362 | Notebook.prototype.expand_all_output = function () { | ||
var ncells = this.ncells(); | ||||
var cells = this.get_cells(); | ||||
for (var i=0; i<ncells; i++) { | ||||
if (cells[i] instanceof IPython.CodeCell) { | ||||
cells[i].output_area.expand(); | ||||
cells[i].output_area.unscroll_area(); | ||||
} | ||||
}; | ||||
// this should not be set if the `collapse` key is removed from nbformat | ||||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r10033 | /** | ||
* Clear each code cell's output area. | ||||
* | ||||
* @method clear_all_output | ||||
*/ | ||||
|
r4543 | Notebook.prototype.clear_all_output = function () { | ||
var ncells = this.ncells(); | ||||
|
r5945 | var cells = this.get_cells(); | ||
|
r4543 | for (var i=0; i<ncells; i++) { | ||
if (cells[i] instanceof IPython.CodeCell) { | ||||
|
r5085 | cells[i].clear_output(true,true,true); | ||
|
r6545 | // Make all In[] prompts blank, as well | ||
// TODO: make this configurable (via checkbox?) | ||||
cells[i].set_input_prompt(); | ||||
|
r4543 | } | ||
}; | ||||
|
r10781 | this.set_dirty(true); | ||
|
r4543 | }; | ||
|
r5959 | |||
|
r5020 | // Other cell functions: line numbers, ... | ||
|
r10033 | /** | ||
* Toggle line numbers in the selected cell's input area. | ||||
* | ||||
* @method cell_toggle_line_numbers | ||||
*/ | ||||
|
r5020 | Notebook.prototype.cell_toggle_line_numbers = function() { | ||
|
r5945 | this.get_selected_cell().toggle_line_numbers(); | ||
|
r5020 | }; | ||
|
r4543 | |||
|
r4352 | // Kernel related things | ||
|
r4315 | |||
|
r10033 | /** | ||
* Start a new kernel and set it on each code cell. | ||||
* | ||||
* @method start_kernel | ||||
*/ | ||||
|
r4352 | Notebook.prototype.start_kernel = function () { | ||
|
r7170 | var base_url = $('body').data('baseKernelUrl') + "kernels"; | ||
|
r7168 | this.kernel = new IPython.Kernel(base_url); | ||
this.kernel.start(this.notebook_id); | ||||
|
r7197 | // Now that the kernel has been created, tell the CodeCells about it. | ||
var ncells = this.ncells(); | ||||
for (var i=0; i<ncells; i++) { | ||||
var cell = this.get_cell(i); | ||||
if (cell instanceof IPython.CodeCell) { | ||||
cell.set_kernel(this.kernel) | ||||
}; | ||||
}; | ||||
|
r4545 | }; | ||
|
r10033 | /** | ||
* Prompt the user to restart the IPython kernel. | ||||
* | ||||
* @method restart_kernel | ||||
*/ | ||||
|
r4545 | Notebook.prototype.restart_kernel = function () { | ||
|
r5025 | var that = this; | ||
|
r10895 | IPython.dialog.modal({ | ||
title : "Restart kernel or continue running?", | ||||
body : $("<p/>").html( | ||||
'Do you want to restart the current kernel? You will lose all variables defined in it.' | ||||
), | ||||
|
r5021 | buttons : { | ||
|
r10895 | "Continue running" : {}, | ||
"Restart" : { | ||||
"class" : "btn-danger", | ||||
"click" : function() { | ||||
that.kernel.restart(); | ||||
} | ||||
|
r4545 | } | ||
} | ||||
}); | ||||
}; | ||||
|
r10033 | /** | ||
* Run the selected cell. | ||||
* | ||||
|
r10127 | * Execute or render cell outputs. | ||
|
r10033 | * | ||
* @method execute_selected_cell | ||||
* @param {Object} options Customize post-execution behavior | ||||
*/ | ||||
|
r4394 | 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 | ||||
|
r8839 | var default_options = {terminal: false, add_new: true}; | ||
|
r5479 | $.extend(default_options, options); | ||
|
r4378 | var that = this; | ||
|
r5945 | var cell = that.get_selected_cell(); | ||
|
r4378 | var cell_index = that.find_cell_index(cell); | ||
if (cell instanceof IPython.CodeCell) { | ||||
|
r7170 | cell.execute(); | ||
|
r4378 | } | ||
|
r4394 | if (default_options.terminal) { | ||
|
r4675 | cell.select_all(); | ||
|
r4378 | } else { | ||
|
r4394 | if ((cell_index === (that.ncells()-1)) && default_options.add_new) { | ||
|
r5945 | that.insert_cell_below('code'); | ||
|
r4394 | // 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); | ||||
}; | ||||
|
r4378 | }; | ||
|
r10781 | this.set_dirty(true); | ||
|
r4378 | }; | ||
|
r10033 | /** | ||
* Execute all cells below the selected cell. | ||||
* | ||||
* @method execute_cells_below | ||||
*/ | ||||
|
r8606 | Notebook.prototype.execute_cells_below = function () { | ||
this.execute_cell_range(this.get_selected_index(), this.ncells()); | ||||
|
r8821 | this.scroll_to_bottom(); | ||
|
r8606 | }; | ||
|
r10033 | /** | ||
* Execute all cells above the selected cell. | ||||
* | ||||
* @method execute_cells_above | ||||
*/ | ||||
|
r8606 | Notebook.prototype.execute_cells_above = function () { | ||
this.execute_cell_range(0, this.get_selected_index()); | ||||
}; | ||||
|
r10033 | /** | ||
* Execute all cells. | ||||
* | ||||
* @method execute_all_cells | ||||
*/ | ||||
|
r4378 | Notebook.prototype.execute_all_cells = function () { | ||
|
r8606 | this.execute_cell_range(0, this.ncells()); | ||
|
r9816 | this.scroll_to_bottom(); | ||
|
r8606 | }; | ||
|
r10033 | /** | ||
* Execute a contiguous range of cells. | ||||
* | ||||
* @method execute_cell_range | ||||
* @param {Number} start Index of the first cell to execute (inclusive) | ||||
* @param {Number} end Index of the last cell to execute (exclusive) | ||||
*/ | ||||
|
r8606 | Notebook.prototype.execute_cell_range = function (start, end) { | ||
for (var i=start; i<end; i++) { | ||||
|
r4378 | this.select(i); | ||
|
r5967 | this.execute_selected_cell({add_new:false}); | ||
|
r4378 | }; | ||
}; | ||||
|
r4352 | // Persistance and loading | ||
|
r10033 | /** | ||
* Getter method for this notebook's ID. | ||||
* | ||||
* @method get_notebook_id | ||||
* @return {String} This notebook's ID | ||||
*/ | ||||
|
r6047 | Notebook.prototype.get_notebook_id = function () { | ||
return this.notebook_id; | ||||
}; | ||||
|
r10033 | /** | ||
* Getter method for this notebook's name. | ||||
* | ||||
* @method get_notebook_name | ||||
* @return {String} This notebook's name | ||||
*/ | ||||
|
r6047 | Notebook.prototype.get_notebook_name = function () { | ||
return this.notebook_name; | ||||
}; | ||||
|
r10033 | /** | ||
* Setter method for this notebook's name. | ||||
* | ||||
* @method set_notebook_name | ||||
* @param {String} name A new name for this notebook | ||||
*/ | ||||
|
r6047 | Notebook.prototype.set_notebook_name = function (name) { | ||
this.notebook_name = name; | ||||
}; | ||||
|
r10033 | /** | ||
* Check that a notebook's name is valid. | ||||
* | ||||
* @method test_notebook_name | ||||
* @param {String} nbname A name for this notebook | ||||
* @return {Boolean} True if the name is valid, false if invalid | ||||
*/ | ||||
|
r6047 | Notebook.prototype.test_notebook_name = function (nbname) { | ||
nbname = nbname || ''; | ||||
if (this.notebook_name_blacklist_re.test(nbname) == false && nbname.length>0) { | ||||
return true; | ||||
} else { | ||||
return false; | ||||
}; | ||||
}; | ||||
|
r10033 | /** | ||
* Load a notebook from JSON (.ipynb). | ||||
* | ||||
* This currently handles one worksheet: others are deleted. | ||||
* | ||||
* @method fromJSON | ||||
* @param {Object} data JSON representation of a notebook | ||||
*/ | ||||
|
r4352 | Notebook.prototype.fromJSON = function (data) { | ||
var ncells = this.ncells(); | ||||
|
r5479 | var i; | ||
for (i=0; i<ncells; i++) { | ||||
|
r4352 | // Always delete cell 0 as they get renumbered as they are deleted. | ||
this.delete_cell(0); | ||||
}; | ||||
|
r6047 | // Save the metadata and name. | ||
|
r4637 | this.metadata = data.metadata; | ||
|
r6047 | this.notebook_name = data.metadata.name; | ||
|
r4484 | // Only handle 1 worksheet for now. | ||
var worksheet = data.worksheets[0]; | ||||
if (worksheet !== undefined) { | ||||
|
r7523 | if (worksheet.metadata) { | ||
this.worksheet_metadata = worksheet.metadata; | ||||
} | ||||
|
r4484 | var new_cells = worksheet.cells; | ||
ncells = new_cells.length; | ||||
var cell_data = null; | ||||
|
r4488 | var new_cell = null; | ||
|
r5479 | for (i=0; i<ncells; i++) { | ||
|
r4484 | cell_data = new_cells[i]; | ||
|
r6477 | // VERSIONHACK: plaintext -> raw | ||
// handle never-released plaintext name for raw cells | ||||
|
r6255 | if (cell_data.cell_type === 'plaintext'){ | ||
cell_data.cell_type = 'raw'; | ||||
} | ||||
|
r8839 | |||
|
r5945 | new_cell = this.insert_cell_below(cell_data.cell_type); | ||
new_cell.fromJSON(cell_data); | ||||
|
r5879 | }; | ||
|
r4352 | }; | ||
|
r7610 | if (data.worksheets.length > 1) { | ||
|
r10895 | IPython.dialog.modal({ | ||
title : "Multiple worksheets", | ||||
body : "This notebook has " + data.worksheets.length + " worksheets, " + | ||||
"but this version of IPython can only handle the first. " + | ||||
"If you save this notebook, worksheets after the first will be lost.", | ||||
|
r7610 | buttons : { | ||
|
r10895 | OK : { | ||
class : "btn-danger" | ||||
|
r7610 | } | ||
|
r10895 | } | ||
|
r7610 | }); | ||
} | ||||
|
r4315 | }; | ||
|
r4352 | |||
|
r10033 | /** | ||
* Dump this notebook into a JSON-friendly object. | ||||
* | ||||
* @method toJSON | ||||
* @return {Object} A JSON-friendly representation of this notebook. | ||||
*/ | ||||
|
r4352 | Notebook.prototype.toJSON = function () { | ||
|
r5945 | var cells = this.get_cells(); | ||
|
r4352 | var ncells = cells.length; | ||
|
r7179 | var cell_array = new Array(ncells); | ||
|
r4352 | for (var i=0; i<ncells; i++) { | ||
cell_array[i] = cells[i].toJSON(); | ||||
}; | ||||
|
r7179 | var data = { | ||
|
r4484 | // Only handle 1 worksheet for now. | ||
|
r7523 | worksheets : [{ | ||
cells: cell_array, | ||||
metadata: this.worksheet_metadata | ||||
}], | ||||
|
r4637 | metadata : this.metadata | ||
|
r5479 | }; | ||
return data; | ||||
|
r4484 | }; | ||
|
r10033 | /** | ||
|
r10505 | * Start an autosave timer, for periodically saving the notebook. | ||
* | ||||
|
r10508 | * @method set_autosave_interval | ||
|
r10505 | * @param {Integer} interval the autosave interval in milliseconds | ||
*/ | ||||
|
r10508 | Notebook.prototype.set_autosave_interval = function (interval) { | ||
|
r10505 | var that = this; | ||
// clear previous interval, so we don't get simultaneous timers | ||||
if (this.autosave_timer) { | ||||
clearInterval(this.autosave_timer); | ||||
} | ||||
|
r10508 | this.autosave_interval = this.minimum_autosave_interval = interval; | ||
|
r10505 | if (interval) { | ||
this.autosave_timer = setInterval(function() { | ||||
|
r10506 | if (that.dirty) { | ||
that.save_notebook(); | ||||
} | ||||
|
r10505 | }, interval); | ||
$([IPython.events]).trigger("autosave_enabled.Notebook", interval); | ||||
} else { | ||||
this.autosave_timer = null; | ||||
$([IPython.events]).trigger("autosave_disabled.Notebook"); | ||||
}; | ||||
}; | ||||
/** | ||||
|
r10033 | * Save this notebook on the server. | ||
* | ||||
* @method save_notebook | ||||
*/ | ||||
|
r4484 | Notebook.prototype.save_notebook = function () { | ||
|
r5958 | // We may want to move the name/id/nbformat logic inside toJSON? | ||
var data = this.toJSON(); | ||||
|
r6047 | data.metadata.name = this.notebook_name; | ||
|
r6061 | data.nbformat = this.nbformat; | ||
|
r7546 | data.nbformat_minor = this.nbformat_minor; | ||
|
r10505 | |||
// time the ajax call for autosave tuning purposes. | ||||
var start = new Date().getTime(); | ||||
|
r5958 | // 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'}, | ||||
|
r10505 | success : $.proxy(this.save_notebook_success, this, start), | ||
error : $.proxy(this.save_notebook_error, this) | ||||
|
r4352 | }; | ||
|
r6047 | $([IPython.events]).trigger('notebook_saving.Notebook'); | ||
|
r9503 | var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id; | ||
|
r5958 | $.ajax(url, settings); | ||
|
r4315 | }; | ||
|
r10501 | |||
|
r10033 | /** | ||
* Success callback for saving a notebook. | ||||
* | ||||
* @method save_notebook_success | ||||
|
r10505 | * @param {Integer} start the time when the save request started | ||
|
r10033 | * @param {Object} data JSON representation of a notebook | ||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
|
r10505 | Notebook.prototype.save_notebook_success = function (start, data, status, xhr) { | ||
|
r10781 | this.set_dirty(false); | ||
|
r6047 | $([IPython.events]).trigger('notebook_saved.Notebook'); | ||
|
r10505 | this._update_autosave_interval(start); | ||
|
r10501 | if (this._checkpoint_after_save) { | ||
this.create_checkpoint(); | ||||
this._checkpoint_after_save = false; | ||||
}; | ||||
|
r5479 | }; | ||
|
r10501 | |||
|
r10033 | /** | ||
|
r10505 | * update the autosave interval based on how long the last save took | ||
* | ||||
* @method _update_autosave_interval | ||||
* @param {Integer} timestamp when the save request started | ||||
*/ | ||||
Notebook.prototype._update_autosave_interval = function (start) { | ||||
var duration = (new Date().getTime() - start); | ||||
if (this.autosave_interval) { | ||||
// new save interval: higher of 10x save duration or parameter (default 30 seconds) | ||||
var interval = Math.max(10 * duration, this.minimum_autosave_interval); | ||||
// round to 10 seconds, otherwise we will be setting a new interval too often | ||||
interval = 10000 * Math.round(interval / 10000); | ||||
// set new interval, if it's changed | ||||
if (interval != this.autosave_interval) { | ||||
|
r10508 | this.set_autosave_interval(interval); | ||
|
r10505 | } | ||
} | ||||
}; | ||||
/** | ||||
|
r10033 | * Failure callback for saving a notebook. | ||
* | ||||
* @method save_notebook_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} status Description of response status | ||||
* @param {String} error_msg HTTP error message | ||||
*/ | ||||
|
r6061 | Notebook.prototype.save_notebook_error = function (xhr, status, error_msg) { | ||
|
r6047 | $([IPython.events]).trigger('notebook_save_failed.Notebook'); | ||
|
r5479 | }; | ||
|
r10501 | |||
|
r10033 | /** | ||
* Request a notebook's data from the server. | ||||
* | ||||
* @method load_notebook | ||||
* @param {String} notebook_id A notebook to load | ||||
*/ | ||||
|
r6047 | Notebook.prototype.load_notebook = function (notebook_id) { | ||
|
r4488 | var that = this; | ||
|
r6047 | this.notebook_id = notebook_id; | ||
|
r4352 | // We do the call with settings so we can set cache to false. | ||
var settings = { | ||||
|
r4488 | processData : false, | ||
cache : false, | ||||
type : "GET", | ||||
dataType : "json", | ||||
|
r6061 | success : $.proxy(this.load_notebook_success,this), | ||
error : $.proxy(this.load_notebook_error,this), | ||||
|
r4352 | }; | ||
|
r6047 | $([IPython.events]).trigger('notebook_loading.Notebook'); | ||
|
r9503 | var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id; | ||
|
r5106 | $.ajax(url, settings); | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r10033 | /** | ||
* Success callback for loading a notebook from the server. | ||||
* | ||||
* Load notebook data from the JSON response. | ||||
* | ||||
* @method load_notebook_success | ||||
* @param {Object} data JSON representation of a notebook | ||||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
|
r6047 | Notebook.prototype.load_notebook_success = function (data, status, xhr) { | ||
|
r4484 | this.fromJSON(data); | ||
if (this.ncells() === 0) { | ||||
|
r5945 | this.insert_cell_below('code'); | ||
|
r4484 | }; | ||
|
r10781 | this.set_dirty(false); | ||
|
r5949 | this.select(0); | ||
|
r5950 | this.scroll_to_top(); | ||
|
r6061 | if (data.orig_nbformat !== undefined && data.nbformat !== data.orig_nbformat) { | ||
|
r10895 | var msg = "This notebook has been converted from an older " + | ||
|
r6061 | "notebook format (v"+data.orig_nbformat+") to the current notebook " + | ||
"format (v"+data.nbformat+"). The next time you save this notebook, the " + | ||||
|
r10895 | "newer notebook format will be used and older versions of IPython " + | ||
|
r6061 | "may not be able to read it. To keep the older version, close the " + | ||
"notebook without saving it."; | ||||
|
r10895 | IPython.dialog.modal({ | ||
title : "Notebook converted", | ||||
body : msg, | ||||
|
r6061 | buttons : { | ||
|
r10895 | OK : { | ||
class : "btn-primary" | ||||
|
r6061 | } | ||
|
r10895 | } | ||
|
r6061 | }); | ||
|
r7546 | } else if (data.orig_nbformat_minor !== undefined && data.nbformat_minor !== data.orig_nbformat_minor) { | ||
var that = this; | ||||
var orig_vs = 'v' + data.nbformat + '.' + data.orig_nbformat_minor; | ||||
var this_vs = 'v' + data.nbformat + '.' + this.nbformat_minor; | ||||
|
r8839 | var msg = "This notebook is version " + orig_vs + ", but we only fully support up to " + | ||
|
r7546 | this_vs + ". You can still work with this notebook, but some features " + | ||
"introduced in later notebook versions may not be available." | ||||
|
r8839 | |||
|
r10895 | IPython.dialog.modal({ | ||
title : "Newer Notebook", | ||||
body : msg, | ||||
|
r7546 | buttons : { | ||
|
r10895 | OK : { | ||
class : "btn-danger" | ||||
|
r7546 | } | ||
|
r10895 | } | ||
|
r7546 | }); | ||
|
r8839 | |||
|
r6061 | } | ||
|
r10503 | |||
|
r7197 | // Create the kernel after the notebook is completely loaded to prevent | ||
// code execution upon loading, which is a security risk. | ||||
|
r11644 | this.start_kernel(); | ||
// load our checkpoint list | ||||
IPython.notebook.list_checkpoints(); | ||||
|
r6047 | $([IPython.events]).trigger('notebook_loaded.Notebook'); | ||
|
r4484 | }; | ||
|
r10033 | /** | ||
* Failure callback for loading a notebook from the server. | ||||
* | ||||
* @method load_notebook_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} textStatus Description of response status | ||||
* @param {String} errorThrow HTTP error message | ||||
*/ | ||||
|
r6061 | Notebook.prototype.load_notebook_error = function (xhr, textStatus, errorThrow) { | ||
|
r11643 | if (xhr.status === 400) { | ||
var msg = errorThrow; | ||||
} else if (xhr.status === 500) { | ||||
var msg = "An unknown error occurred while loading this notebook. " + | ||||
"This version can load notebook formats " + | ||||
"v" + this.nbformat + " or earlier."; | ||||
|
r6061 | } | ||
|
r11643 | IPython.dialog.modal({ | ||
title: "Error loading notebook", | ||||
body : msg, | ||||
buttons : { | ||||
"OK": {} | ||||
} | ||||
}); | ||||
|
r6061 | } | ||
|
r8839 | |||
|
r10501 | /********************* checkpoint-related *********************/ | ||
/** | ||||
* Save the notebook then immediately create a checkpoint. | ||||
* | ||||
* @method save_checkpoint | ||||
*/ | ||||
Notebook.prototype.save_checkpoint = function () { | ||||
this._checkpoint_after_save = true; | ||||
this.save_notebook(); | ||||
}; | ||||
/** | ||||
|
r12050 | * Add a checkpoint for this notebook. | ||
* for use as a callback from checkpoint creation. | ||||
* | ||||
* @method add_checkpoint | ||||
*/ | ||||
Notebook.prototype.add_checkpoint = function (checkpoint) { | ||||
var found = false; | ||||
for (var i = 0; i < this.checkpoints.length; i++) { | ||||
var existing = this.checkpoints[i]; | ||||
if (existing.checkpoint_id == checkpoint.checkpoint_id) { | ||||
found = true; | ||||
this.checkpoints[i] = checkpoint; | ||||
break; | ||||
} | ||||
} | ||||
if (!found) { | ||||
this.checkpoints.push(checkpoint); | ||||
} | ||||
this.last_checkpoint = this.checkpoints[this.checkpoints.length - 1]; | ||||
}; | ||||
/** | ||||
|
r10501 | * List checkpoints for this notebook. | ||
* | ||||
|
r12050 | * @method list_checkpoints | ||
|
r10501 | */ | ||
Notebook.prototype.list_checkpoints = function () { | ||||
var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id + '/checkpoints'; | ||||
$.get(url).done( | ||||
$.proxy(this.list_checkpoints_success, this) | ||||
).fail( | ||||
$.proxy(this.list_checkpoints_error, this) | ||||
); | ||||
}; | ||||
/** | ||||
* Success callback for listing checkpoints. | ||||
* | ||||
* @method list_checkpoint_success | ||||
* @param {Object} data JSON representation of a checkpoint | ||||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
Notebook.prototype.list_checkpoints_success = function (data, status, xhr) { | ||||
var data = $.parseJSON(data); | ||||
|
r12050 | this.checkpoints = data; | ||
|
r10501 | if (data.length) { | ||
|
r12050 | this.last_checkpoint = data[data.length - 1]; | ||
|
r10501 | } else { | ||
this.last_checkpoint = null; | ||||
} | ||||
|
r10520 | $([IPython.events]).trigger('checkpoints_listed.Notebook', [data]); | ||
|
r10501 | }; | ||
/** | ||||
* Failure callback for listing a checkpoint. | ||||
* | ||||
* @method list_checkpoint_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} status Description of response status | ||||
* @param {String} error_msg HTTP error message | ||||
*/ | ||||
Notebook.prototype.list_checkpoints_error = function (xhr, status, error_msg) { | ||||
$([IPython.events]).trigger('list_checkpoints_failed.Notebook'); | ||||
}; | ||||
/** | ||||
* Create a checkpoint of this notebook on the server from the most recent save. | ||||
* | ||||
* @method create_checkpoint | ||||
*/ | ||||
Notebook.prototype.create_checkpoint = function () { | ||||
var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id + '/checkpoints'; | ||||
$.post(url).done( | ||||
$.proxy(this.create_checkpoint_success, this) | ||||
).fail( | ||||
$.proxy(this.create_checkpoint_error, this) | ||||
); | ||||
}; | ||||
/** | ||||
* Success callback for creating a checkpoint. | ||||
* | ||||
* @method create_checkpoint_success | ||||
* @param {Object} data JSON representation of a checkpoint | ||||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
Notebook.prototype.create_checkpoint_success = function (data, status, xhr) { | ||||
var data = $.parseJSON(data); | ||||
|
r12050 | this.add_checkpoint(data); | ||
|
r10501 | $([IPython.events]).trigger('checkpoint_created.Notebook', data); | ||
}; | ||||
/** | ||||
* Failure callback for creating a checkpoint. | ||||
* | ||||
* @method create_checkpoint_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} status Description of response status | ||||
* @param {String} error_msg HTTP error message | ||||
*/ | ||||
Notebook.prototype.create_checkpoint_error = function (xhr, status, error_msg) { | ||||
$([IPython.events]).trigger('checkpoint_failed.Notebook'); | ||||
}; | ||||
|
r10520 | Notebook.prototype.restore_checkpoint_dialog = function (checkpoint) { | ||
|
r10501 | var that = this; | ||
|
r10520 | var checkpoint = checkpoint || this.last_checkpoint; | ||
|
r10501 | if ( ! checkpoint ) { | ||
console.log("restore dialog, but no checkpoint to restore to!"); | ||||
return; | ||||
} | ||||
|
r10895 | var body = $('<div/>').append( | ||
|
r10520 | $('<p/>').addClass("p-space").text( | ||
"Are you sure you want to revert the notebook to " + | ||||
|
r10501 | "the latest checkpoint?" | ||
).append( | ||||
$("<strong/>").text( | ||||
" This cannot be undone." | ||||
) | ||||
) | ||||
).append( | ||||
|
r10520 | $('<p/>').addClass("p-space").text("The checkpoint was last updated at:") | ||
|
r10501 | ).append( | ||
|
r10520 | $('<p/>').addClass("p-space").text( | ||
Date(checkpoint.last_modified) | ||||
).css("text-align", "center") | ||||
|
r10501 | ); | ||
|
r10895 | IPython.dialog.modal({ | ||
title : "Revert notebook to checkpoint", | ||||
body : body, | ||||
|
r10501 | buttons : { | ||
|
r10895 | Revert : { | ||
class : "btn-danger", | ||||
click : function () { | ||||
that.restore_checkpoint(checkpoint.checkpoint_id); | ||||
} | ||||
|
r10501 | }, | ||
|
r10895 | Cancel : {} | ||
|
r10501 | } | ||
}); | ||||
} | ||||
/** | ||||
* Restore the notebook to a checkpoint state. | ||||
* | ||||
* @method restore_checkpoint | ||||
* @param {String} checkpoint ID | ||||
*/ | ||||
Notebook.prototype.restore_checkpoint = function (checkpoint) { | ||||
|
r11226 | $([IPython.events]).trigger('checkpoint_restoring.Notebook', checkpoint); | ||
|
r10501 | var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id + '/checkpoints/' + checkpoint; | ||
$.post(url).done( | ||||
$.proxy(this.restore_checkpoint_success, this) | ||||
).fail( | ||||
$.proxy(this.restore_checkpoint_error, this) | ||||
); | ||||
}; | ||||
/** | ||||
* Success callback for restoring a notebook to a checkpoint. | ||||
* | ||||
* @method restore_checkpoint_success | ||||
* @param {Object} data (ignored, should be empty) | ||||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
Notebook.prototype.restore_checkpoint_success = function (data, status, xhr) { | ||||
$([IPython.events]).trigger('checkpoint_restored.Notebook'); | ||||
this.load_notebook(this.notebook_id); | ||||
}; | ||||
/** | ||||
* Failure callback for restoring a notebook to a checkpoint. | ||||
* | ||||
* @method restore_checkpoint_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} status Description of response status | ||||
* @param {String} error_msg HTTP error message | ||||
*/ | ||||
Notebook.prototype.restore_checkpoint_error = function (xhr, status, error_msg) { | ||||
$([IPython.events]).trigger('checkpoint_restore_failed.Notebook'); | ||||
}; | ||||
/** | ||||
* Delete a notebook checkpoint. | ||||
* | ||||
* @method delete_checkpoint | ||||
* @param {String} checkpoint ID | ||||
*/ | ||||
Notebook.prototype.delete_checkpoint = function (checkpoint) { | ||||
|
r11226 | $([IPython.events]).trigger('checkpoint_deleting.Notebook', checkpoint); | ||
|
r10501 | var url = this.baseProjectUrl() + 'notebooks/' + this.notebook_id + '/checkpoints/' + checkpoint; | ||
$.ajax(url, { | ||||
type: 'DELETE', | ||||
success: $.proxy(this.delete_checkpoint_success, this), | ||||
error: $.proxy(this.delete_notebook_error,this) | ||||
}); | ||||
}; | ||||
/** | ||||
* Success callback for deleting a notebook checkpoint | ||||
* | ||||
* @method delete_checkpoint_success | ||||
* @param {Object} data (ignored, should be empty) | ||||
* @param {String} status Description of response status | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
*/ | ||||
Notebook.prototype.delete_checkpoint_success = function (data, status, xhr) { | ||||
$([IPython.events]).trigger('checkpoint_deleted.Notebook', data); | ||||
this.load_notebook(this.notebook_id); | ||||
}; | ||||
/** | ||||
* Failure callback for deleting a notebook checkpoint. | ||||
* | ||||
* @method delete_checkpoint_error | ||||
* @param {jqXHR} xhr jQuery Ajax object | ||||
* @param {String} status Description of response status | ||||
* @param {String} error_msg HTTP error message | ||||
*/ | ||||
Notebook.prototype.delete_checkpoint_error = function (xhr, status, error_msg) { | ||||
$([IPython.events]).trigger('checkpoint_delete_failed.Notebook'); | ||||
}; | ||||
|
r4352 | IPython.Notebook = Notebook; | ||
|
r5108 | |||
|
r4352 | return IPython; | ||
}(IPython)); | ||||
|
r4315 | |||