notebook.js
2438 lines
| 80.0 KiB
| application/javascript
|
JavascriptLexer
|
r17192 | // Copyright (c) IPython Development Team. | ||
// Distributed under the terms of the Modified BSD License. | ||||
|
r19503 | /** | ||
* @module notebook | ||||
*/ | ||||
|
r17192 | define([ | ||
|
r17194 | 'base/js/namespace', | ||
|
r17200 | 'jquery', | ||
|
r17194 | 'base/js/utils', | ||
'base/js/dialog', | ||||
|
r18999 | 'notebook/js/cell', | ||
|
r17194 | 'notebook/js/textcell', | ||
'notebook/js/codecell', | ||||
|
r19529 | 'services/config', | ||
|
r18422 | 'services/sessions/session', | ||
|
r17194 | 'notebook/js/celltoolbar', | ||
|
r17198 | 'components/marked/lib/marked', | ||
|
r18864 | 'codemirror/lib/codemirror', | ||
'codemirror/addon/runmode/runmode', | ||||
|
r17198 | 'notebook/js/mathjaxutils', | ||
|
r17194 | 'base/js/keyboard', | ||
|
r17215 | 'notebook/js/tooltip', | ||
|
r17217 | 'notebook/js/celltoolbarpresets/default', | ||
'notebook/js/celltoolbarpresets/rawcell', | ||||
'notebook/js/celltoolbarpresets/slideshow', | ||||
|
r17869 | 'notebook/js/scrollmanager' | ||
|
r17192 | ], function ( | ||
IPython, | ||||
|
r18999 | $, | ||
utils, | ||||
dialog, | ||||
cellmod, | ||||
textcell, | ||||
codecell, | ||||
|
r19529 | configmod, | ||
|
r17202 | session, | ||
|
r18999 | celltoolbar, | ||
|
r17194 | marked, | ||
|
r18864 | CodeMirror, | ||
runMode, | ||||
|
r17198 | mathjaxutils, | ||
|
r17215 | keyboard, | ||
|
r17217 | tooltip, | ||
default_celltoolbar, | ||||
rawcell_celltoolbar, | ||||
|
r17869 | slideshow_celltoolbar, | ||
scrollmanager | ||||
|
r17192 | ) { | ||
|
r18991 | "use strict"; | ||
|
r17192 | |||
|
r19503 | /** | ||
|
r19505 | * Contains and manages cells. | ||
|
r19511 | * | ||
|
r19505 | * @class Notebook | ||
|
r19511 | * @param {string} selector | ||
* @param {object} options - Dictionary of keyword arguments. | ||||
* @param {jQuery} options.events - selector of Events | ||||
* @param {KeyboardManager} options.keyboard_manager | ||||
* @param {Contents} options.contents | ||||
* @param {SaveWidget} options.save_widget | ||||
* @param {object} options.config | ||||
* @param {string} options.base_url | ||||
* @param {string} options.notebook_path | ||||
* @param {string} options.notebook_name | ||||
|
r19503 | */ | ||
|
r17210 | var Notebook = function (selector, options) { | ||
|
r19529 | this.config = options.config; | ||
this.class_config = new configmod.ConfigWithDefaults(this.config, | ||||
Notebook.options_default, 'Notebook'); | ||||
|
r17210 | this.base_url = options.base_url; | ||
this.notebook_path = options.notebook_path; | ||||
this.notebook_name = options.notebook_name; | ||||
this.events = options.events; | ||||
this.keyboard_manager = options.keyboard_manager; | ||||
|
r18643 | this.contents = options.contents; | ||
|
r17210 | this.save_widget = options.save_widget; | ||
|
r17216 | this.tooltip = new tooltip.Tooltip(this.events); | ||
|
r17308 | this.ws_url = options.ws_url; | ||
|
r17649 | this._session_starting = false; | ||
|
r17869 | |||
|
r17872 | // Create default scroll manager. | ||
|
r17880 | this.scroll_manager = new scrollmanager.ScrollManager(this); | ||
|
r17872 | |||
|
r17204 | // TODO: This code smells (and the other `= this` line a couple lines down) | ||
// We need a better way to deal with circular instance references. | ||||
|
r17210 | this.keyboard_manager.notebook = this; | ||
this.save_widget.notebook = this; | ||||
|
r17198 | |||
mathjaxutils.init(); | ||||
|
r17194 | |||
if (marked) { | ||||
marked.setOptions({ | ||||
gfm : true, | ||||
tables: true, | ||||
|
r18864 | // FIXME: probably want central config for CodeMirror theme when we have js config | ||
langPrefix: "cm-s-ipython language-", | ||||
highlight: function(code, lang, callback) { | ||||
|
r17194 | if (!lang) { | ||
// no language, no highlight | ||||
|
r18864 | if (callback) { | ||
callback(null, code); | ||||
return; | ||||
} else { | ||||
return code; | ||||
} | ||||
|
r17194 | } | ||
|
r19286 | utils.requireCodeMirrorMode(lang, function (spec) { | ||
|
r18864 | var el = document.createElement("div"); | ||
|
r19286 | var mode = CodeMirror.getMode({}, spec); | ||
|
r18864 | if (!mode) { | ||
console.log("No CodeMirror mode: " + lang); | ||||
callback(null, code); | ||||
return; | ||||
} | ||||
try { | ||||
|
r19286 | CodeMirror.runMode(code, spec, el); | ||
|
r18864 | callback(null, el.innerHTML); | ||
} catch (err) { | ||||
|
r19005 | console.log("Failed to highlight " + lang + " code", err); | ||
|
r18864 | callback(err, code); | ||
} | ||||
}, function (err) { | ||||
console.log("No CodeMirror mode: " + lang); | ||||
callback(err, code); | ||||
}); | ||||
|
r17194 | } | ||
}); | ||||
} | ||||
|
r4352 | this.element = $(selector); | ||
this.element.scroll(); | ||||
this.element.data("notebook", this); | ||||
this.next_prompt_number = 1; | ||||
|
r12986 | this.session = null; | ||
|
r4352 | 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; | ||
|
r19005 | this.writable = false; | ||
|
r14021 | // It is important to start out in command mode to match the intial mode | ||
// of the KeyboardManager. | ||||
|
r14015 | this.mode = 'command'; | ||
|
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; | ||||
|
r7229 | this.notebook_name_blacklist_re = /[\/\\:]/; | ||
|
r18584 | this.nbformat = 4; // Increment this when changing the nbformat | ||
|
r19107 | this.nbformat_minor = this.current_nbformat_minor = 0; // Increment this when changing the nbformat | ||
|
r17425 | this.codemirror_mode = 'ipython'; | ||
|
r4364 | this.create_elements(); | ||
|
r4352 | this.bind_events(); | ||
|
r18991 | this.kernel_selector = null; | ||
this.dirty = null; | ||||
this.trusted = null; | ||||
this._fully_loaded = false; | ||||
|
r17217 | |||
// Trigger cell toolbar registration. | ||||
|
r17454 | default_celltoolbar.register(this); | ||
rawcell_celltoolbar.register(this); | ||||
slideshow_celltoolbar.register(this); | ||||
|
r18991 | |||
// prevent assign to miss-typed properties. | ||||
Object.seal(this); | ||||
|
r4352 | }; | ||
|
r17869 | |||
|
r17785 | Notebook.options_default = { | ||
// can be any cell type, or the special values of | ||||
// 'above', 'below', or 'selected' to get the value from another cell. | ||||
|
r19530 | default_cell_type: 'code' | ||
|
r17785 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Create an HTML and CSS representation of the notebook. | ||||
*/ | ||||
|
r4364 | Notebook.prototype.create_elements = function () { | ||
|
r14018 | var that = this; | ||
this.element.attr('tabindex','-1'); | ||||
this.container = $("<div/>").addClass("container").attr("id", "notebook-container"); | ||||
|
r4364 | // 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. | ||||
|
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); | ||
|
r19872 | this.container.after(end_space); | ||
|
r4364 | }; | ||
|
r10033 | /** | ||
* Bind JavaScript events: key presses and custom IPython events. | ||||
*/ | ||||
|
r4352 | Notebook.prototype.bind_events = function () { | ||
var that = this; | ||||
|
r7170 | |||
|
r17195 | this.events.on('set_next_input.Notebook', function (event, data) { | ||
|
r19250 | if (data.replace) { | ||
data.cell.set_text(data.text); | ||||
|
r19252 | data.cell.clear_output(); | ||
|
r19250 | } else { | ||
var index = that.find_cell_index(data.cell); | ||||
var new_cell = that.insert_cell_below('code',index); | ||||
new_cell.set_text(data.text); | ||||
} | ||||
|
r7168 | that.dirty = true; | ||
}); | ||||
|
r19107 | this.events.on('unrecognized_cell.Cell', function () { | ||
that.warn_nbformat_minor(); | ||||
}); | ||||
this.events.on('unrecognized_output.OutputArea', function () { | ||||
that.warn_nbformat_minor(); | ||||
}); | ||||
|
r17195 | this.events.on('set_dirty.Notebook', function (event, data) { | ||
|
r7228 | that.dirty = data.value; | ||
}); | ||||
|
r18196 | this.events.on('trust_changed.Notebook', function (event, trusted) { | ||
that.trusted = trusted; | ||||
|
r15657 | }); | ||
|
r17195 | this.events.on('select.Cell', function (event, data) { | ||
|
r7168 | var index = that.find_cell_index(data.cell); | ||
|
r7170 | that.select(index); | ||
|
r7168 | }); | ||
|
r14015 | |||
|
r17195 | this.events.on('edit_mode.Cell', function (event, data) { | ||
|
r15629 | that.handle_edit_mode(data.cell); | ||
|
r14015 | }); | ||
|
r14016 | |||
|
r17195 | this.events.on('command_mode.Cell', function (event, data) { | ||
|
r15629 | that.handle_command_mode(data.cell); | ||
|
r14016 | }); | ||
|
r17380 | |||
this.events.on('spec_changed.Kernel', function(event, data) { | ||||
|
r18468 | that.metadata.kernelspec = | ||
|
r19681 | {name: data.name, display_name: data.spec.display_name}; | ||
|
r19886 | // start session if the current session isn't already correct | ||
if (!(this.session && this.session.kernel && this.session.kernel.name === data.name)) { | ||||
that.start_session(data.name); | ||||
} | ||||
|
r18468 | }); | ||
this.events.on('kernel_ready.Kernel', function(event, data) { | ||||
|
r18752 | var kinfo = data.kernel.info_reply; | ||
|
r20048 | if (!kinfo.language_info) { | ||
delete that.metadata.language_info; | ||||
return; | ||||
} | ||||
var langinfo = kinfo.language_info; | ||||
|
r18468 | that.metadata.language_info = langinfo; | ||
|
r18380 | // Mode 'null' should be plain, unhighlighted text. | ||
|
r19021 | var cm_mode = langinfo.codemirror_mode || langinfo.name || 'null'; | ||
|
r18380 | that.set_codemirror_mode(cm_mode); | ||
|
r17380 | }); | ||
|
r7168 | |||
|
r14015 | 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); | ||
|
r14015 | }; | ||
|
r6723 | |||
|
r14015 | this.element.bind('collapse_pager', function (event, extrap) { | ||
|
r15236 | var time = (extrap !== undefined) ? ((extrap.duration !== undefined ) ? extrap.duration : 'fast') : 'fast'; | ||
|
r6723 | collapse_time(time); | ||
|
r4361 | }); | ||
|
r14015 | 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); | ||
|
r14015 | }; | ||
|
r6723 | |||
this.element.bind('expand_pager', function (event, extrap) { | ||||
|
r15236 | 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) { | ||
|
r18219 | that.session.delete(); | ||
|
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 | } | ||
|
r15236 | } | ||
|
r5502 | // Null is the *only* return value that will make the browser not | ||
// pop up the "don't leave" dialog. | ||||
return null; | ||||
|
r11111 | }; | ||
|
r4352 | }; | ||
|
r19107 | |||
|
r19508 | /** | ||
|
r19509 | * Trigger a warning dialog about missing functionality from newer minor versions | ||
|
r19508 | */ | ||
|
r19107 | Notebook.prototype.warn_nbformat_minor = function (event) { | ||
var v = 'v' + this.nbformat + '.'; | ||||
var orig_vs = v + this.nbformat_minor; | ||||
var this_vs = v + this.current_nbformat_minor; | ||||
var msg = "This notebook is version " + orig_vs + ", but we only fully support up to " + | ||||
this_vs + ". You can still work with this notebook, but cell and output types " + | ||||
"introduced in later notebook versions will not be available."; | ||||
dialog.modal({ | ||||
notebook: this, | ||||
keyboard_manager: this.keyboard_manager, | ||||
title : "Newer Notebook", | ||||
body : msg, | ||||
buttons : { | ||||
OK : { | ||||
"class" : "btn-danger" | ||||
} | ||||
} | ||||
}); | ||||
|
r19510 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
|
r10781 | * Set the dirty flag, and trigger the set_dirty.Notebook event | ||
*/ | ||||
Notebook.prototype.set_dirty = function (value) { | ||||
if (value === undefined) { | ||||
value = true; | ||||
} | ||||
|
r19739 | if (this.dirty === value) { | ||
|
r10781 | return; | ||
} | ||||
|
r17195 | this.events.trigger('set_dirty.Notebook', {value: value}); | ||
|
r10781 | }; | ||
/** | ||||
|
r10033 | * Scroll the top of the page to a given cell. | ||
* | ||||
|
r19511 | * @param {integer} index - An index of the cell to view | ||
* @param {integer} time - Animation time in milliseconds | ||||
* @return {integer} Pixel offset from the top of the container | ||||
|
r10033 | */ | ||
|
r19511 | Notebook.prototype.scroll_to_cell = function (index, time) { | ||
|
r8419 | var cells = this.get_cells(); | ||
|
r15236 | time = time || 0; | ||
|
r19511 | index = Math.min(cells.length-1,index); | ||
index = Math.max(0 ,index); | ||||
var scroll_value = cells[index].element.position().top-cells[0].element.position().top ; | ||||
|
r19733 | this.scroll_manager.element.animate({scrollTop:scroll_value}, time); | ||
|
r8419 | return scroll_value; | ||
}; | ||||
|
r10033 | /** | ||
* Scroll to the bottom of the page. | ||||
*/ | ||||
|
r4364 | Notebook.prototype.scroll_to_bottom = function () { | ||
|
r19733 | this.scroll_manager.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0); | ||
|
r4364 | }; | ||
|
r10033 | /** | ||
* Scroll to the top of the page. | ||||
*/ | ||||
|
r4488 | Notebook.prototype.scroll_to_top = function () { | ||
|
r19733 | this.scroll_manager.element.animate({scrollTop:0}, 0); | ||
|
r4488 | }; | ||
|
r12913 | // Edit Notebook metadata | ||
|
r19509 | /** | ||
* Display a dialog that allows the user to edit the Notebook's metadata. | ||||
*/ | ||||
|
r12913 | Notebook.prototype.edit_metadata = function () { | ||
var that = this; | ||||
|
r17214 | dialog.edit_metadata({ | ||
md: this.metadata, | ||||
callback: function (md) { | ||||
that.metadata = md; | ||||
|
r18468 | }, | ||
|
r17214 | name: 'Notebook', | ||
notebook: this, | ||||
keyboard_manager: this.keyboard_manager}); | ||||
|
r12913 | }; | ||
|
r4488 | |||
|
r4352 | // Cell indexing, retrieval, etc. | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get all cell elements in the notebook. | ||||
* | ||||
* @return {jQuery} A selector of all cell elements | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_cell_elements = function () { | ||
|
r19086 | return this.container.find(".cell").not('.cell .cell'); | ||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get a particular cell element. | ||||
* | ||||
|
r19511 | * @param {integer} index An index of a cell to select | ||
|
r10033 | * @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 | /** | ||
|
r14371 | * Try to get a particular cell by msg_id. | ||
* | ||||
|
r19509 | * @param {string} msg_id A message UUID | ||
|
r14371 | * @return {Cell} Cell or null if no cell was found. | ||
*/ | ||||
Notebook.prototype.get_msg_cell = function (msg_id) { | ||||
|
r17202 | return codecell.CodeCell.msg_cells[msg_id] || null; | ||
|
r14371 | }; | ||
/** | ||||
|
r10033 | * Count the cells in this notebook. | ||
* | ||||
|
r19511 | * @return {integer} The number of cells in this notebook | ||
|
r10033 | */ | ||
Notebook.prototype.ncells = function () { | ||||
|
r5945 | return this.get_cell_elements().length; | ||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Get all Cell objects in this notebook. | ||||
* | ||||
* @return {Array} This notebook's Cell objects | ||||
*/ | ||||
|
r5945 | Notebook.prototype.get_cells = function () { | ||
|
r19508 | // TODO: we are often calling cells as cells()[i], which we should optimize | ||
// to cells(i) or a new method. | ||||
|
r5945 | return this.get_cell_elements().toArray().map(function (e) { | ||
|
r4352 | return $(e).data("cell"); | ||
}); | ||||
|
r5479 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
|
r19511 | * Get a Cell objects from this notebook. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} index - An index of a cell to retrieve | ||
|
r18029 | * @return {Cell} Cell or null if no cell was found. | ||
|
r10033 | */ | ||
|
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; | ||||
|
r15236 | }; | ||
|
r5945 | |||
|
r10033 | /** | ||
* Get the cell below a given cell. | ||||
* | ||||
|
r19511 | * @param {Cell} cell | ||
|
r18029 | * @return {Cell} the next cell or null if no cell was found. | ||
|
r10033 | */ | ||
|
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; | ||||
|
r15236 | }; | ||
|
r5945 | |||
|
r10033 | /** | ||
* Get the cell above a given cell. | ||||
* | ||||
|
r19511 | * @param {Cell} cell | ||
|
r18029 | * @return {Cell} The previous cell or null if no cell was found. | ||
|
r10033 | */ | ||
|
r5945 | Notebook.prototype.get_prev_cell = function (cell) { | ||
var result = null; | ||||
var index = this.find_cell_index(cell); | ||||
|
r18020 | if (index !== null && index > 0) { | ||
|
r5945 | result = this.get_cell(index-1); | ||
} | ||||
return result; | ||||
|
r15236 | }; | ||
|
r10033 | |||
/** | ||||
* Get the numeric index of a given cell. | ||||
* | ||||
|
r19511 | * @param {Cell} cell | ||
* @return {integer} The cell's numeric index or null if no cell was found. | ||||
|
r10033 | */ | ||
|
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; | ||||
|
r15236 | } | ||
|
r4352 | }); | ||
return result; | ||||
}; | ||||
|
r4292 | |||
|
r10033 | /** | ||
|
r19511 | * Return given index if defined, or the selected index if not. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} [index] - A cell's index | ||
* @return {integer} cell index | ||||
|
r10033 | */ | ||
|
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. | ||||
|
r19511 | * | ||
|
r10033 | * @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. | ||||
* | ||||
|
r19511 | * @param {integer} index - A cell index | ||
|
r10033 | * @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; | ||||
|
r15236 | } | ||
}; | ||||
|
r4299 | |||
|
r10033 | /** | ||
* Get the index of the currently selected cell. | ||||
|
r19511 | * | ||
* @return {integer} The selected cell's numeric index | ||||
|
r10033 | */ | ||
|
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; | ||||
|
r15236 | } | ||
|
r4352 | }); | ||
return result; | ||||
}; | ||||
|
r4292 | |||
|
r5945 | // Cell selection. | ||
|
r4292 | |||
|
r10033 | /** | ||
* Programmatically select a cell. | ||||
* | ||||
|
r19511 | * @param {integer} index - A cell's index | ||
|
r10033 | * @return {Notebook} This notebook | ||
*/ | ||||
|
r5945 | Notebook.prototype.select = function (index) { | ||
|
r9549 | if (this.is_valid_cell_index(index)) { | ||
|
r15236 | var sindex = this.get_selected_index(); | ||
|
r5946 | if (sindex !== null && index !== sindex) { | ||
|
r15669 | // If we are about to select a different cell, make sure we are | ||
// first in command mode. | ||||
if (this.mode !== 'command') { | ||||
this.command_mode(); | ||||
} | ||||
|
r5945 | this.get_cell(sindex).unselect(); | ||
|
r15236 | } | ||
|
r8839 | var cell = this.get_cell(index); | ||
|
r5994 | cell.select(); | ||
|
r6028 | if (cell.cell_type === 'heading') { | ||
|
r17195 | this.events.trigger('selected_cell_type_changed.Notebook', | ||
|
r6047 | {'cell_type':cell.cell_type,level:cell.level} | ||
); | ||||
|
r6028 | } else { | ||
|
r17195 | this.events.trigger('selected_cell_type_changed.Notebook', | ||
|
r6047 | {'cell_type':cell.cell_type} | ||
); | ||||
|
r15236 | } | ||
} | ||||
|
r4292 | return this; | ||
}; | ||||
|
r10033 | /** | ||
* Programmatically select the next cell. | ||||
* | ||||
* @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. | ||||
* | ||||
* @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 | |||
|
r14015 | // Edit/Command mode | ||
|
r15500 | /** | ||
* Gets the index of the cell that is in edit mode. | ||||
* | ||||
|
r19511 | * @return {integer} index | ||
*/ | ||||
|
r15500 | Notebook.prototype.get_edit_index = function () { | ||
|
r14016 | var result = null; | ||
this.get_cell_elements().filter(function (index) { | ||||
if ($(this).data("cell").mode === 'edit') { | ||||
|
r15500 | result = index; | ||
|
r15236 | } | ||
|
r14016 | }); | ||
return result; | ||||
}; | ||||
|
r15500 | /** | ||
|
r15629 | * Handle when a a cell blurs and the notebook should enter command mode. | ||
|
r15500 | * | ||
|
r19511 | * @param {Cell} [cell] - Cell to enter command mode on. | ||
*/ | ||||
|
r15629 | Notebook.prototype.handle_command_mode = function (cell) { | ||
|
r14015 | if (this.mode !== 'command') { | ||
|
r15669 | cell.command_mode(); | ||
|
r14021 | this.mode = 'command'; | ||
|
r17195 | this.events.trigger('command_mode.Notebook'); | ||
|
r17194 | this.keyboard_manager.command_mode(); | ||
|
r15236 | } | ||
|
r14015 | }; | ||
|
r15500 | /** | ||
|
r15629 | * Make the notebook enter command mode. | ||
|
r19511 | */ | ||
|
r15629 | Notebook.prototype.command_mode = function () { | ||
var cell = this.get_cell(this.get_edit_index()); | ||||
if (cell && this.mode !== 'command') { | ||||
// We don't call cell.command_mode, but rather call cell.focus_cell() | ||||
// which will blur and CM editor and trigger the call to | ||||
// handle_command_mode. | ||||
cell.focus_cell(); | ||||
} | ||||
}; | ||||
/** | ||||
|
r15531 | * Handle when a cell fires it's edit_mode event. | ||
|
r15500 | * | ||
|
r19509 | * @param {Cell} [cell] Cell to enter edit mode on. | ||
|
r19511 | */ | ||
|
r15629 | Notebook.prototype.handle_edit_mode = function (cell) { | ||
|
r15669 | if (cell && this.mode !== 'edit') { | ||
|
r15534 | cell.edit_mode(); | ||
|
r14021 | this.mode = 'edit'; | ||
|
r17195 | this.events.trigger('edit_mode.Notebook'); | ||
|
r17194 | this.keyboard_manager.edit_mode(); | ||
|
r15236 | } | ||
|
r14015 | }; | ||
|
r15500 | /** | ||
|
r15531 | * Make a cell enter edit mode. | ||
|
r19511 | */ | ||
|
r15669 | Notebook.prototype.edit_mode = function () { | ||
var cell = this.get_selected_cell(); | ||||
if (cell && this.mode !== 'edit') { | ||||
|
r15531 | cell.unrender(); | ||
cell.focus_editor(); | ||||
} | ||||
}; | ||||
/** | ||||
|
r15500 | * Focus the currently selected cell. | ||
|
r19511 | */ | ||
|
r14073 | Notebook.prototype.focus_cell = function () { | ||
var cell = this.get_selected_cell(); | ||||
if (cell === null) {return;} // No cell is selected | ||||
cell.focus_cell(); | ||||
}; | ||||
|
r14015 | |||
|
r5945 | // Cell movement | ||
|
r9788 | /** | ||
|
r10033 | * Move given (or selected) cell up and select it. | ||
* | ||||
|
r19511 | * @param {integer} [index] - cell index | ||
|
r10033 | * @return {Notebook} This notebook | ||
|
r19511 | */ | ||
|
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); | ||||
|
r14025 | var cell = this.get_selected_cell(); | ||
cell.focus_cell(); | ||||
|
r15236 | } | ||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
|
r4352 | return this; | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r9788 | /** | ||
|
r19511 | * Move given (or selected) cell down and select it. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} [index] - cell index | ||
|
r10033 | * @return {Notebook} This notebook | ||
|
r19511 | */ | ||
|
r4352 | Notebook.prototype.move_cell_down = function (index) { | ||
|
r9788 | var i = this.index_or_selected(index); | ||
|
r14016 | 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); | ||||
|
r14025 | var cell = this.get_selected_cell(); | ||
cell.focus_cell(); | ||||
|
r15236 | } | ||
} | ||||
|
r10781 | this.set_dirty(); | ||
|
r4352 | return this; | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r5945 | // Insertion, deletion. | ||
|
r4292 | |||
|
r10033 | /** | ||
|
r19582 | * Delete a cell from the notebook without any precautions | ||
* Needed to reload checkpoints and other things like that. | ||||
* | ||||
* @param {integer} [index] - cell's numeric index | ||||
* @return {Notebook} This notebook | ||||
*/ | ||||
|
r19588 | Notebook.prototype._unsafe_delete_cell = function (index) { | ||
|
r19582 | var i = this.index_or_selected(index); | ||
var cell = this.get_cell(i); | ||||
$('#undelete_cell').addClass('disabled'); | ||||
if (this.is_valid_cell_index(i)) { | ||||
var old_ncells = this.ncells(); | ||||
var ce = this.get_cell_element(i); | ||||
ce.remove(); | ||||
this.set_dirty(true); | ||||
} | ||||
return this; | ||||
}; | ||||
/** | ||||
|
r10033 | * Delete a cell from the notebook. | ||
* | ||||
|
r19511 | * @param {integer} [index] - cell's numeric index | ||
|
r10033 | * @return {Notebook} This notebook | ||
*/ | ||||
|
r5945 | Notebook.prototype.delete_cell = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r17998 | var cell = this.get_cell(i); | ||
if (!cell.is_deletable()) { | ||||
return this; | ||||
} | ||||
|
r8691 | this.undelete_backup = cell.toJSON(); | ||
|
r11118 | $('#undelete_cell').removeClass('disabled'); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
|
r14032 | var old_ncells = this.ncells(); | ||
|
r5945 | var ce = this.get_cell_element(i); | ||
ce.remove(); | ||||
|
r14032 | if (i === 0) { | ||
// Always make sure we have at least one cell. | ||||
if (old_ncells === 1) { | ||||
this.insert_cell_below('code'); | ||||
} | ||||
this.select(0); | ||||
this.undelete_index = 0; | ||||
this.undelete_below = false; | ||||
} else if (i === old_ncells-1 && i !== 0) { | ||||
|
r5945 | 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; | ||||
|
r15236 | } | ||
|
r17195 | this.events.trigger('delete.Cell', {'cell': cell, 'index': i}); | ||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
|
r5945 | return this; | ||
|
r5479 | }; | ||
|
r4299 | |||
|
r9550 | /** | ||
|
r14032 | * Restore the most recently deleted cell. | ||
*/ | ||||
Notebook.prototype.undelete_cell = 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); | ||||
if (this.undelete_below) { | ||||
this.select(current_index+1); | ||||
} else { | ||||
this.select(current_index); | ||||
} | ||||
this.undelete_backup = null; | ||||
this.undelete_index = null; | ||||
} | ||||
$('#undelete_cell').addClass('disabled'); | ||||
|
r15236 | }; | ||
|
r14032 | |||
/** | ||||
|
r9550 | * Insert a cell so that after insertion the cell is at given index. | ||
* | ||||
|
r16777 | * If cell type is not provided, it will default to the type of the | ||
* currently active cell. | ||||
* | ||||
|
r19511 | * Similar to insert_above, but index parameter is mandatory. | ||
|
r9550 | * | ||
|
r19511 | * Index will be brought back into the accessible range [0,n]. | ||
|
r9550 | * | ||
|
r19511 | * @param {string} [type] - in ['code','markdown', 'raw'], defaults to 'code' | ||
* @param {integer} [index] - a valid index where to insert cell | ||||
|
r19509 | * @return {Cell|null} created cell or null | ||
|
r19511 | */ | ||
|
r13576 | Notebook.prototype.insert_cell_at_index = function(type, index){ | ||
|
r9677 | var ncells = this.ncells(); | ||
|
r17785 | index = Math.min(index, ncells); | ||
index = Math.max(index, 0); | ||||
|
r6017 | var cell = null; | ||
|
r19529 | type = type || this.class_config.get_sync('default_cell_type'); | ||
|
r17785 | if (type === 'above') { | ||
if (index > 0) { | ||||
type = this.get_cell(index-1).cell_type; | ||||
} else { | ||||
type = 'code'; | ||||
} | ||||
} else if (type === 'below') { | ||||
if (index < ncells) { | ||||
type = this.get_cell(index).cell_type; | ||||
} else { | ||||
type = 'code'; | ||||
} | ||||
} else if (type === 'selected') { | ||||
type = this.get_selected_cell().cell_type; | ||||
} | ||||
|
r9550 | |||
|
r9789 | if (ncells === 0 || this.is_valid_cell_index(index) || index === ncells) { | ||
|
r17210 | var cell_options = { | ||
events: this.events, | ||||
config: this.config, | ||||
keyboard_manager: this.keyboard_manager, | ||||
|
r17215 | notebook: this, | ||
|
r18993 | tooltip: this.tooltip | ||
|
r17210 | }; | ||
|
r18596 | switch(type) { | ||
case 'code': | ||||
|
r17210 | cell = new codecell.CodeCell(this.kernel, cell_options); | ||
|
r5945 | cell.set_input_prompt(); | ||
|
r18596 | break; | ||
case 'markdown': | ||||
|
r17211 | cell = new textcell.MarkdownCell(cell_options); | ||
|
r18596 | break; | ||
case 'raw': | ||||
|
r17211 | cell = new textcell.RawCell(cell_options); | ||
|
r18596 | break; | ||
default: | ||||
|
r18999 | console.log("Unrecognized cell type: ", type, cellmod); | ||
cell = new cellmod.UnrecognizedCell(cell_options); | ||||
|
r9677 | } | ||
|
r14015 | if(this._insert_element_at_index(cell.element,index)) { | ||
|
r5946 | cell.render(); | ||
|
r17195 | this.events.trigger('create.Cell', {'cell': cell, 'index': index}); | ||
|
r14015 | cell.refresh(); | ||
|
r14029 | // We used to select the cell after we refresh it, but there | ||
// are now cases were this method is called where select is | ||||
// not appropriate. The selection logic should be handled by the | ||||
// caller of the the top level insert_cell methods. | ||||
|
r10781 | this.set_dirty(true); | ||
|
r9677 | } | ||
} | ||||
|
r6017 | return cell; | ||
|
r9550 | |||
|
r5479 | }; | ||
|
r4507 | |||
|
r9677 | /** | ||
* Insert an element at given cell index. | ||||
* | ||||
|
r19509 | * @param {HTMLElement} element - a cell element | ||
|
r19511 | * @param {integer} [index] - a valid index where to inser cell | ||
* @returns {boolean} success | ||||
*/ | ||||
|
r9677 | 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 | ||||
|
r19872 | this.container.append(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. | ||||
* | ||||
|
r19511 | * @param {string} [type] - cell type | ||
* @param {integer} [index] - defaults to the currently selected cell | ||||
|
r19509 | * @return {Cell|null} handle to created cell or null | ||
|
r19511 | */ | ||
|
r9550 | 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 | ||||
|
r16777 | * of notebook if index greater than number of cells | ||
|
r9677 | * | ||
|
r19511 | * @param {string} [type] - cell type | ||
* @param {integer} [index] - defaults to the currently selected cell | ||||
|
r19509 | * @return {Cell|null} handle to created cell or null | ||
|
r19511 | */ | ||
|
r13576 | Notebook.prototype.insert_cell_below = function (type, index) { | ||
|
r9677 | index = this.index_or_selected(index); | ||
|
r13576 | return this.insert_cell_at_index(type, index+1); | ||
|
r9677 | }; | ||
/** | ||||
* Insert cell at end of notebook | ||||
* | ||||
|
r19511 | * @param {string} type - cell type | ||
* @return {Cell|null} handle to created cell or null | ||||
*/ | ||||
|
r13576 | Notebook.prototype.insert_cell_at_bottom = function (type){ | ||
|
r9677 | var len = this.ncells(); | ||
|
r13576 | return this.insert_cell_below(type,len-1); | ||
|
r9677 | }; | ||
|
r10033 | /** | ||
* Turn a cell into a code cell. | ||||
* | ||||
|
r19511 | * @param {integer} [index] - cell index | ||
|
r10033 | */ | ||
|
r4507 | Notebook.prototype.to_code = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
|
r17844 | var source_cell = this.get_cell(i); | ||
|
r17203 | if (!(source_cell instanceof codecell.CodeCell)) { | ||
|
r8839 | var target_cell = this.insert_cell_below('code',i); | ||
|
r5945 | var text = source_cell.get_text(); | ||
if (text === source_cell.placeholder) { | ||||
text = ''; | ||||
} | ||||
|
r17844 | //metadata | ||
target_cell.metadata = source_cell.metadata; | ||||
|
r17843 | |||
|
r5945 | 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(); | ||||
|
r17843 | source_cell.element.remove(); | ||
|
r14018 | this.select(i); | ||
|
r16818 | var cursor = source_cell.code_mirror.getCursor(); | ||
target_cell.code_mirror.setCursor(cursor); | ||||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
} | ||||
|
r4352 | }; | ||
|
r4299 | |||
|
r10033 | /** | ||
* Turn a cell into a Markdown cell. | ||||
* | ||||
|
r19511 | * @param {integer} [index] - cell index | ||
|
r10033 | */ | ||
|
r4508 | Notebook.prototype.to_markdown = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r5945 | if (this.is_valid_cell_index(i)) { | ||
|
r17844 | var source_cell = this.get_cell(i); | ||
|
r17843 | |||
|
r17211 | if (!(source_cell instanceof textcell.MarkdownCell)) { | ||
|
r8839 | var target_cell = this.insert_cell_below('markdown',i); | ||
|
r5945 | var text = source_cell.get_text(); | ||
|
r17843 | |||
|
r5945 | if (text === source_cell.placeholder) { | ||
|
r5946 | text = ''; | ||
|
r15236 | } | ||
|
r17844 | // metadata | ||
|
r18752 | target_cell.metadata = source_cell.metadata; | ||
|
r14016 | // We must show the editor before setting its contents | ||
|
r14014 | target_cell.unrender(); | ||
|
r6017 | 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(); | ||||
|
r17843 | source_cell.element.remove(); | ||
|
r14015 | this.select(i); | ||
|
r17211 | if ((source_cell instanceof textcell.TextCell) && source_cell.rendered) { | ||
|
r14943 | target_cell.render(); | ||
} | ||||
|
r16818 | var cursor = source_cell.code_mirror.getCursor(); | ||
target_cell.code_mirror.setCursor(cursor); | ||||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
} | ||||
|
r4507 | }; | ||
|
r10033 | /** | ||
* Turn a cell into a raw text cell. | ||||
* | ||||
|
r19511 | * @param {integer} [index] - cell index | ||
|
r10033 | */ | ||
|
r6248 | Notebook.prototype.to_raw = function (index) { | ||
|
r6017 | var i = this.index_or_selected(index); | ||
if (this.is_valid_cell_index(i)) { | ||||
var target_cell = null; | ||||
|
r17844 | var source_cell = this.get_cell(i); | ||
|
r17843 | |||
|
r17211 | if (!(source_cell instanceof textcell.RawCell)) { | ||
|
r6248 | target_cell = this.insert_cell_below('raw',i); | ||
|
r6017 | var text = source_cell.get_text(); | ||
if (text === source_cell.placeholder) { | ||||
text = ''; | ||||
|
r15236 | } | ||
|
r17844 | //metadata | ||
target_cell.metadata = source_cell.metadata; | ||||
|
r14016 | // We must show the editor before setting its contents | ||
|
r14014 | target_cell.unrender(); | ||
|
r6017 | 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(); | ||||
|
r17843 | source_cell.element.remove(); | ||
|
r14016 | this.select(i); | ||
|
r16818 | var cursor = source_cell.code_mirror.getCursor(); | ||
target_cell.code_mirror.setCursor(cursor); | ||||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
} | ||||
|
r6017 | }; | ||
|
r18680 | |||
|
r19509 | /** | ||
|
r19511 | * Warn about heading cell support removal. | ||
|
r19509 | */ | ||
|
r18680 | Notebook.prototype._warn_heading = function () { | ||
dialog.modal({ | ||||
notebook: this, | ||||
keyboard_manager: this.keyboard_manager, | ||||
title : "Use markdown headings", | ||||
body : $("<p/>").text( | ||||
'IPython no longer uses special heading cells. ' + | ||||
'Instead, write your headings in Markdown cells using # characters:' | ||||
).append($('<pre/>').text( | ||||
'## This is a level 2 heading' | ||||
)), | ||||
buttons : { | ||||
|
r18993 | "OK" : {} | ||
|
r18680 | } | ||
}); | ||||
}; | ||||
|
r10033 | /** | ||
|
r19511 | * Turn a cell into a heading containing markdown cell. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} [index] - cell index | ||
* @param {integer} [level] - heading level (e.g., 1 for h1) | ||||
|
r10033 | */ | ||
|
r19509 | Notebook.prototype.to_heading = function (index, level) { | ||
|
r18680 | this.to_markdown(index); | ||
|
r6019 | level = level || 1; | ||
var i = this.index_or_selected(index); | ||||
if (this.is_valid_cell_index(i)) { | ||||
|
r18680 | var cell = this.get_cell(i); | ||
cell.set_heading_level(level); | ||||
|
r14031 | this.set_dirty(true); | ||
|
r15236 | } | ||
|
r6019 | }; | ||
|
r5945 | // Cut/Copy/Paste | ||
|
r5879 | |||
|
r10033 | /** | ||
|
r19511 | * Enable the UI elements for pasting cells. | ||
|
r10033 | */ | ||
|
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; | ||||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r10033 | /** | ||
|
r19511 | * Disable the UI elements for pasting cells. | ||
|
r10033 | */ | ||
|
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; | ||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Cut a cell. | ||||
*/ | ||||
|
r5879 | Notebook.prototype.cut_cell = function () { | ||
this.copy_cell(); | ||||
this.delete_cell(); | ||||
|
r15236 | }; | ||
|
r5879 | |||
|
r10033 | /** | ||
* Copy a cell. | ||||
*/ | ||||
|
r5879 | Notebook.prototype.copy_cell = function () { | ||
|
r5945 | var cell = this.get_selected_cell(); | ||
|
r5879 | this.clipboard = cell.toJSON(); | ||
|
r17998 | // remove undeletable status from the copied cell | ||
if (this.clipboard.metadata.deletable !== undefined) { | ||||
delete this.clipboard.metadata.deletable; | ||||
} | ||||
|
r5879 | this.enable_paste(); | ||
}; | ||||
|
r10033 | /** | ||
|
r19511 | * Replace the selected cell with the cell in the clipboard. | ||
|
r10033 | */ | ||
|
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)); | ||||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Paste a cell from the clipboard above the selected cell. | ||||
*/ | ||||
|
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); | ||
|
r14972 | new_cell.focus_cell(); | ||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Paste a cell from the clipboard below the selected cell. | ||||
*/ | ||||
|
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); | ||
|
r14972 | new_cell.focus_cell(); | ||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r5945 | // Split/merge | ||
|
r10033 | /** | ||
|
r19511 | * Split the selected cell into two cells. | ||
|
r10033 | */ | ||
|
r5897 | Notebook.prototype.split_cell = function () { | ||
|
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(); | ||||
|
r17417 | cell.set_text(textb); | ||
var new_cell = this.insert_cell_above(cell.cell_type); | ||||
// Unrender the new cell so we can call set_text. | ||||
new_cell.unrender(); | ||||
new_cell.set_text(texta); | ||||
|
r15236 | } | ||
|
r5897 | }; | ||
|
r10033 | /** | ||
|
r19511 | * Merge the selected cell into the cell above it. | ||
|
r10033 | */ | ||
|
r5898 | Notebook.prototype.merge_cell_above = function () { | ||
|
r5945 | var index = this.get_selected_index(); | ||
|
r5946 | var cell = this.get_cell(index); | ||
|
r14028 | var render = cell.rendered; | ||
|
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(); | ||||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r5946 | cell.set_text(upper_text+'\n'+text); | ||
|
r17417 | } else { | ||
|
r14028 | cell.unrender(); // Must unrender before we set_text. | ||
|
r14026 | cell.set_text(upper_text+'\n\n'+text); | ||
|
r14028 | if (render) { | ||
// The rendered state of the final cell should match | ||||
// that of the original selected cell; | ||||
cell.render(); | ||||
} | ||||
|
r15236 | } | ||
|
r5946 | this.delete_cell(index-1); | ||
this.select(this.find_cell_index(cell)); | ||||
|
r15236 | } | ||
|
r5898 | }; | ||
|
r10033 | /** | ||
|
r19511 | * Merge the selected cell into the cell below it. | ||
|
r10033 | */ | ||
|
r5898 | Notebook.prototype.merge_cell_below = function () { | ||
|
r5945 | var index = this.get_selected_index(); | ||
|
r5946 | var cell = this.get_cell(index); | ||
|
r14028 | var render = cell.rendered; | ||
|
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(); | ||||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r5946 | cell.set_text(text+'\n'+lower_text); | ||
|
r17417 | } else { | ||
|
r14028 | cell.unrender(); // Must unrender before we set_text. | ||
|
r14026 | cell.set_text(text+'\n\n'+lower_text); | ||
|
r14028 | if (render) { | ||
// The rendered state of the final cell should match | ||||
// that of the original selected cell; | ||||
cell.render(); | ||||
} | ||||
|
r15236 | } | ||
|
r5946 | this.delete_cell(index+1); | ||
this.select(this.find_cell_index(cell)); | ||||
|
r15236 | } | ||
|
r5898 | }; | ||
|
r5959 | |||
|
r4543 | // Cell collapsing and output clearing | ||
|
r4352 | |||
|
r10033 | /** | ||
* Hide a cell's output. | ||||
* | ||||
|
r19511 | * @param {integer} index - cell index | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.collapse_output = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.collapse_output(); | ||
this.set_dirty(true); | ||||
} | ||||
}; | ||||
/** | ||||
* Hide each code cell's output area. | ||||
*/ | ||||
Notebook.prototype.collapse_all_output = function () { | ||||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14870 | cell.collapse_output(); | ||
|
r14867 | } | ||
|
r14870 | }); | ||
|
r14867 | // this should not be set if the `collapse` key is removed from nbformat | ||
|
r10781 | this.set_dirty(true); | ||
|
r4299 | }; | ||
|
r10033 | /** | ||
* Show a cell's output. | ||||
* | ||||
|
r19511 | * @param {integer} index - cell index | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.expand_output = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.expand_output(); | ||
this.set_dirty(true); | ||||
} | ||||
|
r4352 | }; | ||
|
r14867 | /** | ||
* Expand each code cell's output area, and remove scrollbars. | ||||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.expand_all_output = function () { | ||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14870 | cell.expand_output(); | ||
|
r14867 | } | ||
|
r14870 | }); | ||
|
r14867 | // this should not be set if the `collapse` key is removed from nbformat | ||
|
r10781 | this.set_dirty(true); | ||
|
r4639 | }; | ||
|
r10033 | /** | ||
|
r14867 | * Clear the selected CodeCell's output area. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} index - cell index | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.clear_output = function (index) { | ||
|
r7429 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.clear_output(); | ||
this.set_dirty(true); | ||||
} | ||||
|
r7429 | }; | ||
|
r10033 | /** | ||
|
r14867 | * Clear each code cell's output area. | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.clear_all_output = function () { | ||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14870 | cell.clear_output(); | ||
|
r7362 | } | ||
|
r14870 | }); | ||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r10033 | /** | ||
|
r14867 | * Scroll the selected CodeCell's output area. | ||
* | ||||
|
r19511 | * @param {integer} index - cell index | ||
|
r14867 | */ | ||
Notebook.prototype.scroll_output = function (index) { | ||||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.scroll_output(); | ||
this.set_dirty(true); | ||||
} | ||||
}; | ||||
/** | ||||
|
r19511 | * Expand each code cell's output area and add a scrollbar for long output. | ||
|
r10033 | */ | ||
|
r7362 | Notebook.prototype.scroll_all_output = function () { | ||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14870 | cell.scroll_output(); | ||
|
r7362 | } | ||
|
r14870 | }); | ||
|
r7362 | // this should not be set if the `collapse` key is removed from nbformat | ||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r19511 | /** | ||
* Toggle whether a cell's output is collapsed or expanded. | ||||
|
r10033 | * | ||
|
r19511 | * @param {integer} index - cell index | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.toggle_output = function (index) { | ||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.toggle_output(); | ||
this.set_dirty(true); | ||||
} | ||||
|
r7362 | }; | ||
|
r10033 | /** | ||
|
r19511 | * Toggle the output of all cells. | ||
|
r14871 | */ | ||
Notebook.prototype.toggle_all_output = function () { | ||||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14871 | cell.toggle_output(); | ||
} | ||||
}); | ||||
// this should not be set if the `collapse` key is removed from nbformat | ||||
this.set_dirty(true); | ||||
}; | ||||
/** | ||||
|
r14867 | * Toggle a scrollbar for long cell outputs. | ||
|
r10033 | * | ||
|
r19511 | * @param {integer} index - cell index | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.toggle_output_scroll = function (index) { | ||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
|
r17203 | if (cell !== null && (cell instanceof codecell.CodeCell)) { | ||
|
r14867 | cell.toggle_output_scroll(); | ||
this.set_dirty(true); | ||||
} | ||||
|
r4543 | }; | ||
|
r14871 | /** | ||
* Toggle the scrolling of long output on all cells. | ||||
*/ | ||||
Notebook.prototype.toggle_all_output_scroll = function () { | ||||
|
r18410 | this.get_cells().map(function (cell, i) { | ||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r14871 | cell.toggle_output_scroll(); | ||
} | ||||
}); | ||||
// this should not be set if the `collapse` key is removed from nbformat | ||||
this.set_dirty(true); | ||||
}; | ||||
|
r5959 | |||
|
r5020 | // Other cell functions: line numbers, ... | ||
|
r10033 | /** | ||
* Toggle line numbers in the selected cell's input area. | ||||
*/ | ||||
|
r5020 | Notebook.prototype.cell_toggle_line_numbers = function() { | ||
|
r5945 | this.get_selected_cell().toggle_line_numbers(); | ||
|
r5020 | }; | ||
|
r17376 | |||
/** | ||||
* Set the codemirror mode for all code cells, including the default for | ||||
* new code cells. | ||||
*/ | ||||
Notebook.prototype.set_codemirror_mode = function(newmode){ | ||||
if (newmode === this.codemirror_mode) { | ||||
return; | ||||
} | ||||
this.codemirror_mode = newmode; | ||||
|
r17383 | codecell.CodeCell.options_default.cm_config.mode = newmode; | ||
|
r18596 | |||
|
r18752 | var that = this; | ||
|
r19290 | utils.requireCodeMirrorMode(newmode, function (spec) { | ||
|
r18410 | that.get_cells().map(function(cell, i) { | ||
|
r17383 | if (cell.cell_type === 'code'){ | ||
|
r19290 | cell.code_mirror.setOption('mode', spec); | ||
|
r17376 | // This is currently redundant, because cm_config ends up as | ||
// codemirror's own .options object, but I don't want to | ||||
// rely on that. | ||||
|
r19290 | cell.cm_config.mode = spec; | ||
|
r17376 | } | ||
|
r17383 | }); | ||
|
r18596 | }); | ||
|
r17376 | }; | ||
|
r4543 | |||
|
r12986 | // Session related things | ||
|
r4315 | |||
|
r10033 | /** | ||
|
r12986 | * Start a new session and set it on each code cell. | ||
|
r10033 | */ | ||
|
r17370 | Notebook.prototype.start_session = function (kernel_name) { | ||
|
r17649 | if (this._session_starting) { | ||
throw new session.SessionAlreadyStarting(); | ||||
} | ||||
this._session_starting = true; | ||||
|
r18222 | |||
var options = { | ||||
|
r17212 | base_url: this.base_url, | ||
|
r17308 | ws_url: this.ws_url, | ||
|
r17212 | notebook_path: this.notebook_path, | ||
notebook_name: this.notebook_name, | ||||
|
r17370 | kernel_name: kernel_name, | ||
|
r18222 | notebook: this | ||
}; | ||||
var success = $.proxy(this._session_started, this); | ||||
var failure = $.proxy(this._session_start_failed, this); | ||||
|
r17223 | |||
|
r18222 | if (this.session !== null) { | ||
this.session.restart(options, success, failure); | ||||
} else { | ||||
this.session = new session.Session(options); | ||||
this.session.start(success, failure); | ||||
} | ||||
|
r4545 | }; | ||
|
r12999 | |||
/** | ||||
|
r14342 | * Once a session is started, link the code cells to the kernel and pass the | ||
|
r19511 | * comm manager to the widget manager. | ||
|
r10033 | */ | ||
|
r17649 | Notebook.prototype._session_started = function (){ | ||
this._session_starting = false; | ||||
|
r13133 | this.kernel = this.session.kernel; | ||
|
r7197 | var ncells = this.ncells(); | ||
for (var i=0; i<ncells; i++) { | ||||
var cell = this.get_cell(i); | ||||
|
r17203 | if (cell instanceof codecell.CodeCell) { | ||
|
r13133 | cell.set_kernel(this.session.kernel); | ||
|
r15236 | } | ||
} | ||||
|
r4545 | }; | ||
|
r19511 | |||
|
r19503 | /** | ||
|
r19511 | * Called when the session fails to start. | ||
|
r19503 | */ | ||
|
r19511 | Notebook.prototype._session_start_failed = function(jqxhr, status, error){ | ||
|
r17649 | this._session_starting = false; | ||
utils.log_ajax_error(jqxhr, status, error); | ||||
}; | ||||
|
r17870 | |||
|
r10033 | /** | ||
* Prompt the user to restart the IPython kernel. | ||||
*/ | ||||
|
r4545 | Notebook.prototype.restart_kernel = function () { | ||
|
r5025 | var that = this; | ||
|
r17202 | dialog.modal({ | ||
|
r17212 | notebook: this, | ||
keyboard_manager: this.keyboard_manager, | ||||
|
r10895 | title : "Restart kernel or continue running?", | ||
|
r14634 | body : $("<p/>").text( | ||
|
r10895 | '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() { | ||||
|
r18199 | that.kernel.restart(); | ||
|
r10895 | } | ||
|
r4545 | } | ||
} | ||||
}); | ||||
}; | ||||
|
r12994 | |||
|
r10033 | /** | ||
|
r14085 | * Execute or render cell outputs and go into command mode. | ||
|
r10033 | */ | ||
|
r14085 | Notebook.prototype.execute_cell = function () { | ||
|
r19503 | // mode = shift, ctrl, alt | ||
|
r14085 | var cell = this.get_selected_cell(); | ||
cell.execute(); | ||||
|
r15493 | this.command_mode(); | ||
|
r14085 | this.set_dirty(true); | ||
|
r15236 | }; | ||
|
r14085 | |||
/** | ||||
* Execute or render cell outputs and insert a new cell below. | ||||
*/ | ||||
Notebook.prototype.execute_cell_and_insert_below = function () { | ||||
|
r14016 | var cell = this.get_selected_cell(); | ||
var cell_index = this.find_cell_index(cell); | ||||
|
r14015 | |||
cell.execute(); | ||||
|
r14016 | |||
// If we are at the end always insert a new cell and return | ||||
|
r14085 | if (cell_index === (this.ncells()-1)) { | ||
|
r15669 | this.command_mode(); | ||
|
r16778 | this.insert_cell_below(); | ||
|
r15669 | this.select(cell_index+1); | ||
this.edit_mode(); | ||||
|
r14016 | this.scroll_to_bottom(); | ||
this.set_dirty(true); | ||||
return; | ||||
|
r14085 | } | ||
|
r15669 | |||
this.command_mode(); | ||||
|
r16778 | this.insert_cell_below(); | ||
|
r15669 | this.select(cell_index+1); | ||
this.edit_mode(); | ||||
|
r14085 | this.set_dirty(true); | ||
}; | ||||
/** | ||||
* Execute or render cell outputs and select the next cell. | ||||
*/ | ||||
Notebook.prototype.execute_cell_and_select_below = function () { | ||||
var cell = this.get_selected_cell(); | ||||
var cell_index = this.find_cell_index(cell); | ||||
cell.execute(); | ||||
// If we are at the end always insert a new cell and return | ||||
if (cell_index === (this.ncells()-1)) { | ||||
|
r15669 | this.command_mode(); | ||
|
r16778 | this.insert_cell_below(); | ||
|
r15669 | this.select(cell_index+1); | ||
this.edit_mode(); | ||||
|
r14085 | this.scroll_to_bottom(); | ||
this.set_dirty(true); | ||||
return; | ||||
|
r14015 | } | ||
|
r14085 | |||
|
r15493 | this.command_mode(); | ||
|
r15669 | this.select(cell_index+1); | ||
|
r15749 | this.focus_cell(); | ||
|
r10781 | this.set_dirty(true); | ||
|
r4378 | }; | ||
|
r10033 | /** | ||
* Execute all cells below the selected cell. | ||||
*/ | ||||
|
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. | ||||
*/ | ||||
|
r8606 | Notebook.prototype.execute_cells_above = function () { | ||
this.execute_cell_range(0, this.get_selected_index()); | ||||
}; | ||||
|
r10033 | /** | ||
* 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. | ||||
* | ||||
|
r19511 | * @param {integer} start - index of the first cell to execute (inclusive) | ||
* @param {integer} end - index of the last cell to execute (exclusive) | ||||
|
r10033 | */ | ||
|
r8606 | Notebook.prototype.execute_cell_range = function (start, end) { | ||
|
r15669 | this.command_mode(); | ||
|
r8606 | for (var i=start; i<end; i++) { | ||
|
r4378 | this.select(i); | ||
|
r14085 | this.execute_cell(); | ||
|
r15236 | } | ||
|
r4378 | }; | ||
|
r4352 | // Persistance and loading | ||
|
r10033 | /** | ||
* Getter method for this notebook's name. | ||||
* | ||||
|
r19509 | * @return {string} This notebook's name (excluding file extension) | ||
|
r10033 | */ | ||
|
r6047 | Notebook.prototype.get_notebook_name = function () { | ||
|
r13032 | var nbname = this.notebook_name.substring(0,this.notebook_name.length-6); | ||
|
r13005 | return nbname; | ||
|
r6047 | }; | ||
|
r10033 | /** | ||
* Setter method for this notebook's name. | ||||
* | ||||
|
r19511 | * @param {string} name | ||
|
r10033 | */ | ||
|
r6047 | Notebook.prototype.set_notebook_name = function (name) { | ||
|
r18752 | var parent = utils.url_path_split(this.notebook_path)[0]; | ||
|
r6047 | this.notebook_name = name; | ||
|
r18752 | this.notebook_path = utils.url_path_join(parent, name); | ||
|
r6047 | }; | ||
|
r10033 | /** | ||
* Check that a notebook's name is valid. | ||||
* | ||||
|
r19509 | * @param {string} nbname - A name for this notebook | ||
* @return {boolean} True if the name is valid, false if invalid | ||||
|
r10033 | */ | ||
|
r6047 | Notebook.prototype.test_notebook_name = function (nbname) { | ||
nbname = nbname || ''; | ||||
|
r15236 | if (nbname.length>0 && !this.notebook_name_blacklist_re.test(nbname)) { | ||
|
r6047 | return true; | ||
} else { | ||||
return false; | ||||
|
r15236 | } | ||
|
r6047 | }; | ||
|
r10033 | /** | ||
* Load a notebook from JSON (.ipynb). | ||||
* | ||||
|
r19511 | * @param {object} data - JSON representation of a notebook | ||
|
r10033 | */ | ||
|
r4352 | Notebook.prototype.fromJSON = function (data) { | ||
|
r18249 | |||
|
r13032 | var content = data.content; | ||
|
r4352 | 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. | ||
|
r19588 | this._unsafe_delete_cell(0); | ||
|
r15236 | } | ||
|
r6047 | // Save the metadata and name. | ||
|
r13032 | this.metadata = content.metadata; | ||
this.notebook_name = data.name; | ||||
|
r18752 | this.notebook_path = data.path; | ||
|
r15657 | var trusted = true; | ||
|
r17377 | |||
|
r18468 | // Set the codemirror mode from language_info metadata | ||
if (this.metadata.language_info !== undefined) { | ||||
var langinfo = this.metadata.language_info; | ||||
// Mode 'null' should be plain, unhighlighted text. | ||||
|
r19021 | var cm_mode = langinfo.codemirror_mode || langinfo.name || 'null'; | ||
|
r18468 | this.set_codemirror_mode(cm_mode); | ||
} | ||||
|
r18584 | var new_cells = content.cells; | ||
ncells = new_cells.length; | ||||
var cell_data = null; | ||||
var new_cell = null; | ||||
for (i=0; i<ncells; i++) { | ||||
cell_data = new_cells[i]; | ||||
new_cell = this.insert_cell_at_index(cell_data.cell_type, i); | ||||
new_cell.fromJSON(cell_data); | ||||
|
r19739 | if (new_cell.cell_type === 'code' && !new_cell.output_area.trusted) { | ||
|
r18584 | trusted = false; | ||
|
r15236 | } | ||
} | ||||
|
r17833 | if (trusted !== this.trusted) { | ||
|
r15657 | this.trusted = trusted; | ||
|
r18196 | this.events.trigger("trust_changed.Notebook", trusted); | ||
|
r15657 | } | ||
|
r4315 | }; | ||
|
r4352 | |||
|
r10033 | /** | ||
* Dump this notebook into a JSON-friendly object. | ||||
* | ||||
|
r19511 | * @return {object} A JSON-friendly representation of this notebook. | ||
|
r10033 | */ | ||
|
r4352 | Notebook.prototype.toJSON = function () { | ||
|
r19503 | // remove the conversion indicator, which only belongs in-memory | ||
|
r18584 | delete this.metadata.orig_nbformat; | ||
delete this.metadata.orig_nbformat_minor; | ||||
|
r5945 | var cells = this.get_cells(); | ||
|
r4352 | var ncells = cells.length; | ||
|
r7179 | var cell_array = new Array(ncells); | ||
|
r15657 | var trusted = true; | ||
|
r4352 | for (var i=0; i<ncells; i++) { | ||
|
r15657 | var cell = cells[i]; | ||
|
r19739 | if (cell.cell_type === 'code' && !cell.output_area.trusted) { | ||
|
r15657 | trusted = false; | ||
} | ||||
cell_array[i] = cell.toJSON(); | ||||
|
r15236 | } | ||
|
r7179 | var data = { | ||
|
r18584 | cells: cell_array, | ||
|
r18675 | metadata: this.metadata, | ||
nbformat: this.nbformat, | ||||
nbformat_minor: this.nbformat_minor | ||||
|
r5479 | }; | ||
|
r19739 | if (trusted !== this.trusted) { | ||
|
r15657 | this.trusted = trusted; | ||
|
r17195 | this.events.trigger("trust_changed.Notebook", trusted); | ||
|
r15657 | } | ||
|
r5479 | return data; | ||
|
r4484 | }; | ||
|
r10033 | /** | ||
|
r19511 | * Start an autosave timer which periodically saves the notebook. | ||
|
r10505 | * | ||
|
r19509 | * @param {integer} interval - the autosave interval in milliseconds | ||
|
r10505 | */ | ||
|
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); | ||||
} | ||||
|
r19005 | if (!this.writable) { | ||
// disable autosave if not writable | ||||
interval = 0; | ||||
} | ||||
|
r10505 | |||
|
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); | ||
|
r17195 | this.events.trigger("autosave_enabled.Notebook", interval); | ||
|
r10505 | } else { | ||
this.autosave_timer = null; | ||||
|
r17195 | this.events.trigger("autosave_disabled.Notebook"); | ||
|
r15236 | } | ||
|
r10505 | }; | ||
/** | ||||
|
r15881 | * Save this notebook on the server. This becomes a notebook instance's | ||
* .save_notebook method *after* the entire notebook has been loaded. | ||||
|
r10033 | */ | ||
|
r18774 | Notebook.prototype.save_notebook = function () { | ||
|
r19005 | if (!this._fully_loaded) { | ||
|
r18992 | this.events.trigger('notebook_save_failed.Notebook', | ||
new Error("Load failed, save is disabled") | ||||
); | ||||
|
r18993 | return; | ||
|
r19005 | } else if (!this.writable) { | ||
this.events.trigger('notebook_save_failed.Notebook', | ||||
new Error("Notebook is read-only") | ||||
); | ||||
return; | ||||
|
r18991 | } | ||
|
r19005 | |||
|
r19359 | // Trigger an event before save, which allows listeners to modify | ||
// the notebook as needed. | ||||
this.events.trigger('before_save.Notebook'); | ||||
|
r13032 | // Create a JSON model to be sent to the server. | ||
|
r18653 | var model = { | ||
type : "notebook", | ||||
|
r18675 | content : this.toJSON() | ||
|
r18653 | }; | ||
|
r10505 | // time the ajax call for autosave tuning purposes. | ||
var start = new Date().getTime(); | ||||
|
r18653 | |||
var that = this; | ||||
|
r18969 | return this.contents.save(this.notebook_path, model).then( | ||
|
r18829 | $.proxy(this.save_notebook_success, this, start), | ||
function (error) { | ||||
|
r18752 | that.events.trigger('notebook_save_failed.Notebook', error); | ||
|
r18653 | } | ||
|
r18829 | ); | ||
|
r4315 | }; | ||
|
r10501 | |||
|
r10033 | /** | ||
* Success callback for saving a notebook. | ||||
* | ||||
|
r19509 | * @param {integer} start - Time when the save request start | ||
|
r19511 | * @param {object} data - JSON representation of a notebook | ||
|
r10033 | */ | ||
|
r18661 | Notebook.prototype.save_notebook_success = function (start, data) { | ||
|
r10781 | this.set_dirty(false); | ||
|
r18249 | if (data.message) { | ||
// save succeeded, but validation failed. | ||||
var body = $("<div>"); | ||||
var title = "Notebook validation failed"; | ||||
body.append($("<p>").text( | ||||
"The save operation succeeded," + | ||||
" but the notebook does not appear to be valid." + | ||||
" The validation error was:" | ||||
)).append($("<div>").addClass("validation-error").append( | ||||
$("<pre>").text(data.message) | ||||
)); | ||||
dialog.modal({ | ||||
notebook: this, | ||||
keyboard_manager: this.keyboard_manager, | ||||
title: title, | ||||
body: body, | ||||
buttons : { | ||||
OK : { | ||||
"class" : "btn-primary" | ||||
} | ||||
} | ||||
}); | ||||
} | ||||
|
r17195 | this.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; | ||||
|
r15236 | } | ||
|
r5479 | }; | ||
|
r10501 | |||
|
r10033 | /** | ||
|
r19511 | * Update the autosave interval based on the duration of the last save. | ||
|
r10505 | * | ||
|
r19509 | * @param {integer} timestamp - when the save request started | ||
|
r10505 | */ | ||
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 | ||||
|
r19739 | if (interval !== this.autosave_interval) { | ||
|
r10508 | this.set_autosave_interval(interval); | ||
|
r10505 | } | ||
} | ||||
}; | ||||
|
r12997 | |||
|
r15655 | /** | ||
* Explicitly trust the output of this notebook. | ||||
*/ | ||||
|
r18774 | Notebook.prototype.trust_notebook = function () { | ||
|
r15655 | var body = $("<div>").append($("<p>") | ||
|
r15673 | .text("A trusted IPython notebook may execute hidden malicious code ") | ||
.append($("<strong>") | ||||
.append( | ||||
$("<em>").text("when you open it") | ||||
) | ||||
).append(".").append( | ||||
" Selecting trust will immediately reload this notebook in a trusted state." | ||||
).append( | ||||
" For more information, see the " | ||||
|
r16046 | ).append($("<a>").attr("href", "http://ipython.org/ipython-doc/2/notebook/security.html") | ||
|
r15673 | .text("IPython security documentation") | ||
).append(".") | ||||
); | ||||
|
r15655 | |||
var nb = this; | ||||
|
r17202 | dialog.modal({ | ||
|
r17212 | notebook: this, | ||
keyboard_manager: this.keyboard_manager, | ||||
|
r15655 | title: "Trust this notebook?", | ||
body: body, | ||||
buttons: { | ||||
Cancel : {}, | ||||
Trust : { | ||||
class : "btn-danger", | ||||
click : function () { | ||||
|
r15663 | var cells = nb.get_cells(); | ||
for (var i = 0; i < cells.length; i++) { | ||||
var cell = cells[i]; | ||||
|
r19739 | if (cell.cell_type === 'code') { | ||
|
r15663 | cell.output_area.trusted = true; | ||
} | ||||
} | ||||
|
r17833 | nb.events.on('notebook_saved.Notebook', function () { | ||
|
r15663 | window.location.reload(); | ||
}); | ||||
nb.save_notebook(); | ||||
|
r15655 | } | ||
} | ||||
} | ||||
}); | ||||
}; | ||||
|
r19508 | /** | ||
* Make a copy of the current notebook. | ||||
*/ | ||||
|
r19005 | Notebook.prototype.copy_notebook = function () { | ||
var that = this; | ||||
|
r15238 | var base_url = this.base_url; | ||
|
r18774 | var w = window.open(); | ||
|
r18752 | var parent = utils.url_path_split(this.notebook_path)[0]; | ||
|
r18829 | this.contents.copy(this.notebook_path, parent).then( | ||
function (data) { | ||||
|
r18774 | w.location = utils.url_join_encode( | ||
|
r18752 | base_url, 'notebooks', data.path | ||
|
r18774 | ); | ||
}, | ||||
|
r18829 | function(error) { | ||
|
r18774 | w.close(); | ||
|
r19005 | that.events.trigger('notebook_copy_failed', error); | ||
|
r18829 | } | ||
); | ||||
|
r13017 | }; | ||
|
r19684 | |||
/** | ||||
* Ensure a filename has the right extension | ||||
* Returns the filename with the appropriate extension, appending if necessary. | ||||
*/ | ||||
Notebook.prototype.ensure_extension = function (name) { | ||||
if (!name.match(/\.ipynb$/)) { | ||||
name = name + ".ipynb"; | ||||
} | ||||
return name; | ||||
}; | ||||
|
r12997 | |||
|
r19508 | /** | ||
|
r19511 | * Rename the notebook. | ||
|
r19508 | * @param {string} new_name | ||
* @return {Promise} promise that resolves when the notebook is renamed. | ||||
*/ | ||||
|
r18653 | Notebook.prototype.rename = function (new_name) { | ||
|
r19684 | new_name = this.ensure_extension(new_name); | ||
|
r14965 | |||
var that = this; | ||||
|
r18752 | var parent = utils.url_path_split(this.notebook_path)[0]; | ||
var new_path = utils.url_path_join(parent, new_name); | ||||
|
r18964 | return this.contents.rename(this.notebook_path, new_path).then( | ||
|
r18829 | function (json) { | ||
|
r18752 | that.notebook_name = json.name; | ||
that.notebook_path = json.path; | ||||
that.session.rename_notebook(json.path); | ||||
|
r18654 | that.events.trigger('notebook_renamed.Notebook', json); | ||
|
r18964 | } | ||
|
r18829 | ); | ||
|
r14965 | }; | ||
|
r19508 | /** | ||
* Delete this notebook | ||||
*/ | ||||
|
r18634 | Notebook.prototype.delete = function () { | ||
|
r18752 | this.contents.delete(this.notebook_path); | ||
|
r15236 | }; | ||
|
r13018 | |||
|
r10033 | /** | ||
* Request a notebook's data from the server. | ||||
* | ||||
|
r19509 | * @param {string} notebook_path - A notebook to load | ||
|
r10033 | */ | ||
|
r18752 | Notebook.prototype.load_notebook = function (notebook_path) { | ||
|
r19884 | var that = this; | ||
|
r13063 | this.notebook_path = notebook_path; | ||
|
r18752 | this.notebook_name = utils.url_path_split(this.notebook_path)[1]; | ||
|
r17195 | this.events.trigger('notebook_loading.Notebook'); | ||
|
r18827 | this.contents.get(notebook_path, {type: 'notebook'}).then( | ||
|
r19885 | $.proxy(this.load_notebook_success, this), | ||
|
r18827 | $.proxy(this.load_notebook_error, this) | ||
); | ||||
|
r5479 | }; | ||
|
r4352 | |||
|
r10033 | /** | ||
* Success callback for loading a notebook from the server. | ||||
* | ||||
* Load notebook data from the JSON response. | ||||
* | ||||
|
r19511 | * @param {object} data JSON representation of a notebook | ||
|
r10033 | */ | ||
|
r18661 | Notebook.prototype.load_notebook_success = function (data) { | ||
|
r18752 | var failed, msg; | ||
|
r18249 | try { | ||
this.fromJSON(data); | ||||
} catch (e) { | ||||
failed = e; | ||||
console.log("Notebook failed to load from JSON:", e); | ||||
} | ||||
if (failed || data.message) { | ||||
// *either* fromJSON failed or validation failed | ||||
var body = $("<div>"); | ||||
var title; | ||||
if (failed) { | ||||
title = "Notebook failed to load"; | ||||
body.append($("<p>").text( | ||||
"The error was: " | ||||
)).append($("<div>").addClass("js-error").text( | ||||
failed.toString() | ||||
)).append($("<p>").text( | ||||
"See the error console for details." | ||||
)); | ||||
} else { | ||||
title = "Notebook validation failed"; | ||||
} | ||||
if (data.message) { | ||||
if (failed) { | ||||
|
r18752 | msg = "The notebook also failed validation:"; | ||
|
r18249 | } else { | ||
msg = "An invalid notebook may not function properly." + | ||||
|
r18752 | " The validation error was:"; | ||
|
r18249 | } | ||
body.append($("<p>").text( | ||||
msg | ||||
)).append($("<div>").addClass("validation-error").append( | ||||
$("<pre>").text(data.message) | ||||
)); | ||||
} | ||||
dialog.modal({ | ||||
notebook: this, | ||||
keyboard_manager: this.keyboard_manager, | ||||
title: title, | ||||
body: body, | ||||
buttons : { | ||||
OK : { | ||||
"class" : "btn-primary" | ||||
} | ||||
} | ||||
}); | ||||
} | ||||
|
r4484 | if (this.ncells() === 0) { | ||
|
r5945 | this.insert_cell_below('code'); | ||
|
r15541 | this.edit_mode(0); | ||
|
r14015 | } else { | ||
this.select(0); | ||||
|
r15629 | this.handle_command_mode(this.get_cell(0)); | ||
|
r15236 | } | ||
|
r10781 | this.set_dirty(false); | ||
|
r5950 | this.scroll_to_top(); | ||
|
r19005 | this.writable = data.writable || false; | ||
|
r18584 | var nbmodel = data.content; | ||
var orig_nbformat = nbmodel.metadata.orig_nbformat; | ||||
var orig_nbformat_minor = nbmodel.metadata.orig_nbformat_minor; | ||||
if (orig_nbformat !== undefined && nbmodel.nbformat !== orig_nbformat) { | ||||
|
r18672 | var src; | ||
|
r18686 | if (nbmodel.nbformat > orig_nbformat) { | ||
|
r18672 | src = " an older notebook format "; | ||
} else { | ||||
src = " a newer notebook format "; | ||||
} | ||||
|
r18752 | msg = "This notebook has been converted from" + src + | ||
|
r18686 | "(v"+orig_nbformat+") to the current notebook " + | ||
|
r18685 | "format (v"+nbmodel.nbformat+"). The next time you save this notebook, the " + | ||
|
r18672 | "current notebook format will be used."; | ||
|
r18686 | if (nbmodel.nbformat > orig_nbformat) { | ||
|
r18672 | msg += " Older versions of IPython may not be able to read the new format."; | ||
} else { | ||||
msg += " Some features of the original notebook may not be available."; | ||||
} | ||||
msg += " To preserve the original version, close the " + | ||||
"notebook without saving it."; | ||||
|
r17202 | dialog.modal({ | ||
|
r17212 | notebook: this, | ||
keyboard_manager: this.keyboard_manager, | ||||
|
r10895 | title : "Notebook converted", | ||
body : msg, | ||||
|
r6061 | buttons : { | ||
|
r10895 | OK : { | ||
class : "btn-primary" | ||||
|
r6061 | } | ||
|
r10895 | } | ||
|
r6061 | }); | ||
|
r19107 | } else if (this.nbformat_minor < nbmodel.nbformat_minor) { | ||
this.nbformat_minor = nbmodel.nbformat_minor; | ||||
|
r6061 | } | ||
|
r10503 | |||
|
r15236 | if (this.session === null) { | ||
|
r19257 | var kernel_name; | ||
if (this.metadata.kernelspec) { | ||||
var kernelspec = this.metadata.kernelspec || {}; | ||||
kernel_name = kernelspec.name; | ||||
} else { | ||||
kernel_name = utils.get_url_param('kernel_name'); | ||||
} | ||||
|
r19886 | if (kernel_name) { | ||
// setting kernel_name here triggers start_session | ||||
this.kernel_selector.set_kernel(kernel_name); | ||||
} else { | ||||
// start a new session with the server's default kernel | ||||
// spec_changed events will fire after kernel is loaded | ||||
this.start_session(); | ||||
} | ||||
|
r12986 | } | ||
|
r11644 | // load our checkpoint list | ||
|
r13679 | this.list_checkpoints(); | ||
// load toolbar state | ||||
if (this.metadata.celltoolbar) { | ||||
|
r17202 | celltoolbar.CellToolbar.global_show(); | ||
|
r17454 | celltoolbar.CellToolbar.activate_preset(this.metadata.celltoolbar); | ||
|
r16534 | } else { | ||
|
r17202 | celltoolbar.CellToolbar.global_hide(); | ||
|
r13679 | } | ||
|
r19005 | |||
if (!this.writable) { | ||||
this.set_autosave_interval(0); | ||||
this.events.trigger('notebook_read_only.Notebook'); | ||||
} | ||||
|
r15881 | // now that we're fully loaded, it is safe to restore save functionality | ||
|
r18991 | this._fully_loaded = true; | ||
|
r17195 | this.events.trigger('notebook_loaded.Notebook'); | ||
|
r4484 | }; | ||
|
r19404 | Notebook.prototype.set_kernelselector = function(k_selector){ | ||
this.kernel_selector = k_selector; | ||||
}; | ||||
|
r10033 | /** | ||
* Failure callback for loading a notebook from the server. | ||||
* | ||||
|
r18661 | * @param {Error} error | ||
*/ | ||||
Notebook.prototype.load_notebook_error = function (error) { | ||||
this.events.trigger('notebook_load_failed.Notebook', error); | ||||
var msg; | ||||
|
r18752 | if (error.name === utils.XHR_ERROR && error.xhr.status === 500) { | ||
|
r18661 | utils.log_ajax_error(error.xhr, error.xhr_status, error.xhr_error); | ||
msg = "An unknown error occurred while loading this notebook. " + | ||||
|
r11643 | "This version can load notebook formats " + | ||
|
r18661 | "v" + this.nbformat + " or earlier. See the server log for details."; | ||
} else { | ||||
msg = error.message; | ||||
|
r6061 | } | ||
|
r17202 | dialog.modal({ | ||
|
r17212 | notebook: this, | ||
keyboard_manager: this.keyboard_manager, | ||||
|
r11643 | title: "Error loading notebook", | ||
body : msg, | ||||
buttons : { | ||||
"OK": {} | ||||
} | ||||
}); | ||||
|
r15236 | }; | ||
|
r8839 | |||
|
r19511 | /********************* checkpoint-related ********************/ | ||
|
r10501 | |||
/** | ||||
* Save the notebook then immediately create a checkpoint. | ||||
*/ | ||||
Notebook.prototype.save_checkpoint = function () { | ||||
this._checkpoint_after_save = true; | ||||
this.save_notebook(); | ||||
}; | ||||
/** | ||||
|
r12050 | * Add a checkpoint for this notebook. | ||
*/ | ||||
Notebook.prototype.add_checkpoint = function (checkpoint) { | ||||
var found = false; | ||||
for (var i = 0; i < this.checkpoints.length; i++) { | ||||
var existing = this.checkpoints[i]; | ||||
|
r19739 | if (existing.id === checkpoint.id) { | ||
|
r12050 | 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. | ||
*/ | ||||
Notebook.prototype.list_checkpoints = function () { | ||||
|
r18652 | var that = this; | ||
|
r18829 | this.contents.list_checkpoints(this.notebook_path).then( | ||
$.proxy(this.list_checkpoints_success, this), | ||||
function(error) { | ||||
|
r18752 | that.events.trigger('list_checkpoints_failed.Notebook', error); | ||
|
r18652 | } | ||
|
r18829 | ); | ||
|
r10501 | }; | ||
/** | ||||
* Success callback for listing checkpoints. | ||||
* | ||||
|
r19511 | * @param {object} data - JSON representation of a checkpoint | ||
|
r10501 | */ | ||
|
r18661 | Notebook.prototype.list_checkpoints_success = function (data) { | ||
|
r12050 | this.checkpoints = data; | ||
|
r10501 | if (data.length) { | ||
|
r12050 | this.last_checkpoint = data[data.length - 1]; | ||
|
r10501 | } else { | ||
this.last_checkpoint = null; | ||||
} | ||||
|
r17195 | this.events.trigger('checkpoints_listed.Notebook', [data]); | ||
|
r10501 | }; | ||
/** | ||||
* Create a checkpoint of this notebook on the server from the most recent save. | ||||
*/ | ||||
Notebook.prototype.create_checkpoint = function () { | ||||
|
r18652 | var that = this; | ||
|
r18829 | this.contents.create_checkpoint(this.notebook_path).then( | ||
$.proxy(this.create_checkpoint_success, this), | ||||
function (error) { | ||||
|
r18752 | that.events.trigger('checkpoint_failed.Notebook', error); | ||
|
r18652 | } | ||
|
r18829 | ); | ||
|
r10501 | }; | ||
/** | ||||
* Success callback for creating a checkpoint. | ||||
* | ||||
|
r19511 | * @param {object} data - JSON representation of a checkpoint | ||
|
r10501 | */ | ||
|
r18661 | Notebook.prototype.create_checkpoint_success = function (data) { | ||
|
r12050 | this.add_checkpoint(data); | ||
|
r17195 | this.events.trigger('checkpoint_created.Notebook', data); | ||
|
r10501 | }; | ||
|
r19509 | /** | ||
* Display the restore checkpoint dialog | ||||
* @param {string} checkpoint ID | ||||
*/ | ||||
|
r10520 | Notebook.prototype.restore_checkpoint_dialog = function (checkpoint) { | ||
|
r10501 | var that = this; | ||
|
r15236 | 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 | ); | ||
|
r17202 | dialog.modal({ | ||
|
r17212 | notebook: this, | ||
keyboard_manager: this.keyboard_manager, | ||||
|
r10895 | title : "Revert notebook to checkpoint", | ||
body : body, | ||||
|
r10501 | buttons : { | ||
|
r10895 | Revert : { | ||
class : "btn-danger", | ||||
click : function () { | ||||
|
r13122 | that.restore_checkpoint(checkpoint.id); | ||
|
r10895 | } | ||
|
r10501 | }, | ||
|
r10895 | Cancel : {} | ||
|
r10501 | } | ||
}); | ||||
|
r15236 | }; | ||
|
r10501 | |||
/** | ||||
* Restore the notebook to a checkpoint state. | ||||
* | ||||
|
r19509 | * @param {string} checkpoint ID | ||
|
r10501 | */ | ||
Notebook.prototype.restore_checkpoint = function (checkpoint) { | ||||
|
r17195 | this.events.trigger('notebook_restoring.Notebook', checkpoint); | ||
|
r18652 | var that = this; | ||
|
r18829 | this.contents.restore_checkpoint(this.notebook_path, checkpoint).then( | ||
$.proxy(this.restore_checkpoint_success, this), | ||||
function (error) { | ||||
|
r18752 | that.events.trigger('checkpoint_restore_failed.Notebook', error); | ||
|
r18652 | } | ||
|
r18829 | ); | ||
|
r10501 | }; | ||
/** | ||||
* Success callback for restoring a notebook to a checkpoint. | ||||
*/ | ||||
|
r18661 | Notebook.prototype.restore_checkpoint_success = function () { | ||
|
r17195 | this.events.trigger('checkpoint_restored.Notebook'); | ||
|
r18752 | this.load_notebook(this.notebook_path); | ||
|
r10501 | }; | ||
/** | ||||
* Delete a notebook checkpoint. | ||||
* | ||||
|
r19509 | * @param {string} checkpoint ID | ||
|
r10501 | */ | ||
Notebook.prototype.delete_checkpoint = function (checkpoint) { | ||||
|
r17195 | this.events.trigger('notebook_restoring.Notebook', checkpoint); | ||
|
r18652 | var that = this; | ||
|
r18829 | this.contents.delete_checkpoint(this.notebook_path, checkpoint).then( | ||
$.proxy(this.delete_checkpoint_success, this), | ||||
function (error) { | ||||
|
r18661 | that.events.trigger('checkpoint_delete_failed.Notebook', error); | ||
|
r18652 | } | ||
|
r18829 | ); | ||
|
r10501 | }; | ||
/** | ||||
|
r19511 | * Success callback for deleting a notebook checkpoint. | ||
|
r10501 | */ | ||
|
r18661 | Notebook.prototype.delete_checkpoint_success = function () { | ||
this.events.trigger('checkpoint_deleted.Notebook'); | ||||
|
r18752 | this.load_notebook(this.notebook_path); | ||
|
r10501 | }; | ||
|
r17192 | // For backwards compatability. | ||
|
r4352 | IPython.Notebook = Notebook; | ||
|
r17201 | return {'Notebook': Notebook}; | ||
|
r17192 | }); | ||