notebook.js
2430 lines
| 79.2 KiB
| application/javascript
|
JavascriptLexer
|
r4609 | //---------------------------------------------------------------------------- | ||
|
r13063 | // Copyright (C) 2011 The IPython Development Team | ||
|
r4609 | // | ||
// 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; | ||
|
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) { | ||
|
r15234 | this.options = options = options || {}; | ||
|
r15238 | this.base_url = options.base_url; | ||
|
r15234 | this.notebook_path = options.notebook_path; | ||
this.notebook_name = options.notebook_name; | ||||
|
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; | ||
|
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; | ||||
|
r7523 | // single worksheet for now | ||
this.worksheet_metadata = {}; | ||||
|
r7229 | this.notebook_name_blacklist_re = /[\/\\:]/; | ||
|
r15234 | this.nbformat = 3; // Increment this when changing the nbformat | ||
this.nbformat_minor = 0; // Increment this when changing the nbformat | ||||
|
r4357 | this.style(); | ||
|
r4364 | this.create_elements(); | ||
|
r4352 | this.bind_events(); | ||
|
r15881 | this.save_notebook = function() { // don't allow save until notebook_loaded | ||
|
r15994 | this.save_notebook_error(null, null, "Load failed, save is disabled"); | ||
|
r15881 | }; | ||
|
r4352 | }; | ||
|
r4292 | |||
|
r10033 | /** | ||
* Tweak the notebook's CSS style. | ||||
* | ||||
* @method style | ||||
*/ | ||||
|
r4357 | Notebook.prototype.style = function () { | ||
|
r4363 | $('div#notebook').addClass('border-box-sizing'); | ||
|
r4357 | }; | ||
|
r10033 | /** | ||
* Create an HTML and CSS representation of the notebook. | ||||
* | ||||
* @method create_elements | ||||
*/ | ||||
|
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); | ||
this.container.append(end_space); | ||||
|
r4364 | }; | ||
|
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; | ||||
}); | ||||
|
r15657 | $([IPython.events]).on('trust_changed.Notebook', function (event, data) { | ||
that.trusted = data.value; | ||||
}); | ||||
|
r7168 | $([IPython.events]).on('select.Cell', function (event, data) { | ||
var index = that.find_cell_index(data.cell); | ||||
|
r7170 | that.select(index); | ||
|
r7168 | }); | ||
|
r14015 | |||
|
r15501 | $([IPython.events]).on('edit_mode.Cell', function (event, data) { | ||
|
r15629 | that.handle_edit_mode(data.cell); | ||
|
r14015 | }); | ||
|
r14016 | |||
|
r15501 | $([IPython.events]).on('command_mode.Cell', function (event, data) { | ||
|
r15629 | that.handle_command_mode(data.cell); | ||
|
r14016 | }); | ||
|
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 | |||
|
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) { | ||
|
r12999 | that.session.kill_kernel(); | ||
|
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 | }; | ||
|
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(); | ||||
|
r15236 | time = time || 0; | ||
|
r8419 | 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); | ||||
}; | ||||
|
r12913 | // Edit Notebook metadata | ||
Notebook.prototype.edit_metadata = function () { | ||||
var that = this; | ||||
IPython.dialog.edit_metadata(this.metadata, function (md) { | ||||
that.metadata = md; | ||||
}, 'Notebook'); | ||||
}; | ||||
|
r4488 | |||
|
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 | /** | ||
|
r14371 | * Try to get a particular cell by msg_id. | ||
* | ||||
* @method get_msg_cell | ||||
* @param {String} msg_id A message UUID | ||||
* @return {Cell} Cell or null if no cell was found. | ||||
*/ | ||||
Notebook.prototype.get_msg_cell = function (msg_id) { | ||||
|
r14833 | return IPython.CodeCell.msg_cells[msg_id] || null; | ||
|
r14371 | }; | ||
/** | ||||
|
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; | ||||
|
r15236 | }; | ||
|
r5945 | |||
|
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; | ||||
|
r15236 | }; | ||
|
r5945 | |||
|
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; | ||||
|
r15236 | }; | ||
|
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; | ||||
|
r15236 | } | ||
|
r4352 | }); | ||
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; | ||||
|
r15236 | } | ||
}; | ||||
|
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; | ||||
|
r15236 | } | ||
|
r4352 | }); | ||
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)) { | ||
|
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') { | ||
|
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} | ||||
); | ||||
|
r15236 | } | ||
} | ||||
|
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 | |||
|
r14015 | // Edit/Command mode | ||
|
r15500 | /** | ||
* Gets the index of the cell that is in edit mode. | ||||
* | ||||
* @method get_edit_index | ||||
* | ||||
* @return index {int} | ||||
**/ | ||||
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 | * | ||
|
r15629 | * @method handle_command_mode | ||
* @param [cell] {Cell} Cell to enter command mode on. | ||||
|
r15500 | **/ | ||
|
r15629 | Notebook.prototype.handle_command_mode = function (cell) { | ||
|
r14015 | if (this.mode !== 'command') { | ||
|
r15669 | cell.command_mode(); | ||
|
r14021 | this.mode = 'command'; | ||
|
r15493 | $([IPython.events]).trigger('command_mode.Notebook'); | ||
|
r14021 | IPython.keyboard_manager.command_mode(); | ||
|
r15236 | } | ||
|
r14015 | }; | ||
|
r15500 | /** | ||
|
r15629 | * Make the notebook enter command mode. | ||
* | ||||
* @method command_mode | ||||
**/ | ||||
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 | * | ||
|
r15531 | * @method handle_edit_mode | ||
|
r15629 | * @param [cell] {Cell} Cell to enter edit mode on. | ||
|
r15500 | **/ | ||
|
r15629 | Notebook.prototype.handle_edit_mode = function (cell) { | ||
|
r15669 | if (cell && this.mode !== 'edit') { | ||
|
r15534 | cell.edit_mode(); | ||
|
r14021 | this.mode = 'edit'; | ||
|
r15493 | $([IPython.events]).trigger('edit_mode.Notebook'); | ||
|
r14020 | IPython.keyboard_manager.edit_mode(); | ||
|
r15236 | } | ||
|
r14015 | }; | ||
|
r15500 | /** | ||
|
r15531 | * Make a cell enter edit mode. | ||
* | ||||
|
r15541 | * @method edit_mode | ||
|
r15531 | **/ | ||
|
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. | ||
* | ||||
* @method focus_cell | ||||
**/ | ||||
|
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. | ||
* | ||||
|
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); | ||||
|
r14025 | var cell = this.get_selected_cell(); | ||
cell.focus_cell(); | ||||
|
r15236 | } | ||
|
r10781 | this.set_dirty(true); | ||
|
r15236 | } | ||
|
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); | ||
|
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 | /** | ||
* 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)) { | ||
|
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 | } | ||
|
r11214 | $([IPython.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. | ||
* | ||||
* @method undelete | ||||
*/ | ||||
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. | ||||
* | ||||
|
r9550 | * Similar to insert_above, but index parameter is mandatory | ||
* | ||||
|
r16777 | * Index will be brought back into the accessible range [0,n] | ||
|
r9550 | * | ||
|
r10033 | * @method insert_cell_at_index | ||
|
r16777 | * @param [type] {string} in ['code','markdown','heading'], defaults to 'code' | ||
* @param [index] {int} a valid index where to insert cell | ||||
|
r9550 | * | ||
|
r9677 | * @return cell {cell|null} created cell or null | ||
|
r9550 | **/ | ||
|
r13576 | Notebook.prototype.insert_cell_at_index = function(type, index){ | ||
|
r9677 | var ncells = this.ncells(); | ||
|
r15236 | index = Math.min(index,ncells); | ||
index = Math.max(index,0); | ||||
|
r6017 | var cell = null; | ||
|
r16777 | type = type || this.get_selected_cell().cell_type; | ||
|
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 | } | ||
|
r14015 | if(this._insert_element_at_index(cell.element,index)) { | ||
|
r5946 | cell.render(); | ||
|
r11214 | $([IPython.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. | ||||
* | ||||
|
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 | ||
|
r16777 | * @param [type] {string} cell type | ||
|
r9550 | * @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 | ||||
|
r16777 | * of notebook if index greater than number of cells | ||
|
r9677 | * | ||
* default index value is the one of currently selected cell | ||||
* | ||||
* @method insert_cell_below | ||||
|
r16777 | * @param [type] {string} cell type | ||
|
r9677 | * @param [index] {integer} | ||
* | ||||
* @return handle to created cell or null | ||||
* | ||||
**/ | ||||
|
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 | ||||
* | ||||
* @method insert_cell_at_bottom | ||||
|
r10033 | * @param {String} type cell type | ||
|
r9677 | * | ||
* @return the added 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. | ||||
* | ||||
* @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(); | ||
|
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. | ||||
* | ||||
* @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 = ''; | ||
|
r15236 | } | ||
|
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(); | ||||
|
r6017 | source_element.remove(); | ||
|
r14015 | this.select(i); | ||
|
r14943 | if ((source_cell instanceof IPython.TextCell) && source_cell.rendered) { | ||
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. | ||||
* | ||||
* @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 = ''; | ||||
|
r15236 | } | ||
|
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(); | ||||
|
r6017 | source_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 | }; | ||
|
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 = ''; | ||||
|
r15236 | } | ||
|
r14016 | // We must show the editor before setting its contents | ||
|
r6019 | target_cell.set_level(level); | ||
|
r14014 | target_cell.unrender(); | ||
|
r6019 | 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(); | ||
|
r14016 | this.select(i); | ||
|
r16818 | var cursor = source_cell.code_mirror.getCursor(); | ||
target_cell.code_mirror.setCursor(cursor); | ||||
|
r14943 | if ((source_cell instanceof IPython.TextCell) && source_cell.rendered) { | ||
target_cell.render(); | ||||
} | ||||
|
r15236 | } | ||
|
r14031 | this.set_dirty(true); | ||
|
r6047 | $([IPython.events]).trigger('selected_cell_type_changed.Notebook', | ||
{'cell_type':'heading',level:level} | ||||
); | ||||
|
r15236 | } | ||
|
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; | ||||
|
r15236 | } | ||
|
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; | ||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r10033 | /** | ||
* Cut a cell. | ||||
* | ||||
* @method cut_cell | ||||
*/ | ||||
|
r5879 | Notebook.prototype.cut_cell = function () { | ||
this.copy_cell(); | ||||
this.delete_cell(); | ||||
|
r15236 | }; | ||
|
r5879 | |||
|
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)); | ||||
|
r15236 | } | ||
|
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); | ||
|
r14972 | new_cell.focus_cell(); | ||
|
r15236 | } | ||
|
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); | ||
|
r14972 | new_cell.focus_cell(); | ||
|
r15236 | } | ||
|
r5879 | }; | ||
|
r5945 | // Split/merge | ||
|
r10033 | /** | ||
* Split the selected cell into two, at the cursor. | ||||
* | ||||
* @method split_cell | ||||
*/ | ||||
|
r5897 | Notebook.prototype.split_cell = function () { | ||
|
r14061 | var mdc = IPython.MarkdownCell; | ||
var rc = IPython.RawCell; | ||||
|
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) { | ||
|
r14057 | // In this case the operations keep the notebook in its existing mode | ||
// so we don't need to do any post-op mode changes. | ||||
|
r12956 | cell.set_text(textb); | ||
var new_cell = this.insert_cell_above('code'); | ||||
new_cell.set_text(texta); | ||||
|
r14086 | } else if ((cell instanceof mdc && !cell.rendered) || (cell instanceof rc)) { | ||
|
r14060 | // We know cell is !rendered so we can use set_text. | ||
|
r12956 | cell.set_text(textb); | ||
|
r14061 | var new_cell = this.insert_cell_above(cell.cell_type); | ||
|
r14060 | // Unrender the new cell so we can call set_text. | ||
|
r14057 | new_cell.unrender(); | ||
|
r14060 | new_cell.set_text(texta); | ||
|
r10375 | } | ||
|
r15236 | } | ||
|
r5897 | }; | ||
|
r10033 | /** | ||
* Combine the selected cell into the cell above it. | ||||
* | ||||
* @method merge_cell_above | ||||
*/ | ||||
|
r5898 | Notebook.prototype.merge_cell_above = function () { | ||
|
r14061 | var mdc = IPython.MarkdownCell; | ||
var rc = IPython.RawCell; | ||||
|
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(); | ||||
|
r5946 | if (cell instanceof IPython.CodeCell) { | ||
cell.set_text(upper_text+'\n'+text); | ||||
|
r14061 | } else if ((cell instanceof mdc) || (cell instanceof rc)) { | ||
|
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 | /** | ||
* Combine the selected cell into the cell below it. | ||||
* | ||||
* @method merge_cell_below | ||||
*/ | ||||
|
r5898 | Notebook.prototype.merge_cell_below = function () { | ||
|
r14061 | var mdc = IPython.MarkdownCell; | ||
var rc = IPython.RawCell; | ||||
|
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(); | ||||
|
r5946 | if (cell instanceof IPython.CodeCell) { | ||
cell.set_text(text+'\n'+lower_text); | ||||
|
r14061 | } else if ((cell instanceof mdc) || (cell instanceof rc)) { | ||
|
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. | ||||
* | ||||
|
r14867 | * @method collapse_output | ||
|
r10033 | * @param {Number} index A cell's numeric index | ||
*/ | ||||
|
r14867 | Notebook.prototype.collapse_output = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.collapse_output(); | ||||
this.set_dirty(true); | ||||
} | ||||
}; | ||||
/** | ||||
* Hide each code cell's output area. | ||||
* | ||||
* @method collapse_all_output | ||||
*/ | ||||
Notebook.prototype.collapse_all_output = function () { | ||||
|
r14870 | $.map(this.get_cells(), function (cell, i) { | ||
if (cell instanceof IPython.CodeCell) { | ||||
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. | ||||
* | ||||
|
r14867 | * @method expand_output | ||
|
r10033 | * @param {Number} index A cell's numeric index | ||
*/ | ||||
|
r14867 | Notebook.prototype.expand_output = function (index) { | ||
|
r4352 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.expand_output(); | ||||
this.set_dirty(true); | ||||
} | ||||
|
r4352 | }; | ||
|
r14867 | /** | ||
* Expand each code cell's output area, and remove scrollbars. | ||||
|
r10033 | * | ||
|
r14867 | * @method expand_all_output | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.expand_all_output = function () { | ||
|
r14870 | $.map(this.get_cells(), function (cell, i) { | ||
if (cell instanceof IPython.CodeCell) { | ||||
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 | * | ||
|
r14867 | * @method clear_output | ||
|
r10033 | * @param {Number} index A cell's numeric index | ||
*/ | ||||
|
r14867 | Notebook.prototype.clear_output = function (index) { | ||
|
r7429 | var i = this.index_or_selected(index); | ||
|
r14867 | var cell = this.get_cell(i); | ||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.clear_output(); | ||||
this.set_dirty(true); | ||||
} | ||||
|
r7429 | }; | ||
|
r10033 | /** | ||
|
r14867 | * Clear each code cell's output area. | ||
|
r10033 | * | ||
|
r14867 | * @method clear_all_output | ||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.clear_all_output = function () { | ||
|
r14870 | $.map(this.get_cells(), function (cell, i) { | ||
if (cell instanceof IPython.CodeCell) { | ||||
cell.clear_output(); | ||||
|
r7362 | } | ||
|
r14870 | }); | ||
|
r10781 | this.set_dirty(true); | ||
|
r7362 | }; | ||
|
r10033 | /** | ||
|
r14867 | * Scroll the selected CodeCell's output area. | ||
* | ||||
* @method scroll_output | ||||
* @param {Number} index A cell's numeric index | ||||
*/ | ||||
Notebook.prototype.scroll_output = function (index) { | ||||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.scroll_output(); | ||||
this.set_dirty(true); | ||||
} | ||||
}; | ||||
/** | ||||
|
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 () { | ||
|
r14870 | $.map(this.get_cells(), function (cell, i) { | ||
if (cell instanceof IPython.CodeCell) { | ||||
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 | }; | ||
|
r14867 | /** Toggle whether a cell's output is collapsed or expanded. | ||
|
r10033 | * | ||
|
r14867 | * @method toggle_output | ||
* @param {Number} index A cell's numeric index | ||||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.toggle_output = function (index) { | ||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.toggle_output(); | ||||
this.set_dirty(true); | ||||
} | ||||
|
r7362 | }; | ||
|
r10033 | /** | ||
|
r14871 | * Hide/show the output of all cells. | ||
* | ||||
* @method toggle_all_output | ||||
*/ | ||||
Notebook.prototype.toggle_all_output = function () { | ||||
$.map(this.get_cells(), function (cell, i) { | ||||
if (cell instanceof IPython.CodeCell) { | ||||
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 | * | ||
|
r14867 | * @method toggle_output_scroll | ||
* @param {Number} index A cell's numeric index | ||||
|
r10033 | */ | ||
|
r14867 | Notebook.prototype.toggle_output_scroll = function (index) { | ||
var i = this.index_or_selected(index); | ||||
var cell = this.get_cell(i); | ||||
if (cell !== null && (cell instanceof IPython.CodeCell)) { | ||||
cell.toggle_output_scroll(); | ||||
this.set_dirty(true); | ||||
} | ||||
|
r4543 | }; | ||
|
r14871 | /** | ||
* Toggle the scrolling of long output on all cells. | ||||
* | ||||
* @method toggle_all_output_scrolling | ||||
*/ | ||||
Notebook.prototype.toggle_all_output_scroll = function () { | ||||
$.map(this.get_cells(), function (cell, i) { | ||||
if (cell instanceof IPython.CodeCell) { | ||||
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. | ||||
* | ||||
* @method cell_toggle_line_numbers | ||||
*/ | ||||
|
r5020 | Notebook.prototype.cell_toggle_line_numbers = function() { | ||
|
r5945 | this.get_selected_cell().toggle_line_numbers(); | ||
|
r5020 | }; | ||
|
r4543 | |||
|
r12986 | // Session related things | ||
|
r4315 | |||
|
r10033 | /** | ||
|
r12986 | * Start a new session and set it on each code cell. | ||
|
r10033 | * | ||
|
r12986 | * @method start_session | ||
|
r10033 | */ | ||
|
r12986 | Notebook.prototype.start_session = function () { | ||
|
r15234 | this.session = new IPython.Session(this, this.options); | ||
|
r13133 | this.session.start($.proxy(this._session_started, this)); | ||
|
r4545 | }; | ||
|
r12999 | |||
/** | ||||
|
r14342 | * Once a session is started, link the code cells to the kernel and pass the | ||
* comm manager to the widget manager | ||||
|
r12999 | * | ||
|
r10033 | */ | ||
|
r13133 | Notebook.prototype._session_started = function(){ | ||
this.kernel = this.session.kernel; | ||||
|
r7197 | var ncells = this.ncells(); | ||
for (var i=0; i<ncells; i++) { | ||||
var cell = this.get_cell(i); | ||||
if (cell instanceof IPython.CodeCell) { | ||||
|
r13133 | cell.set_kernel(this.session.kernel); | ||
|
r15236 | } | ||
} | ||||
|
r4545 | }; | ||
|
r12999 | |||
|
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?", | ||||
|
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() { | ||||
|
r12994 | that.session.restart_kernel(); | ||
|
r10895 | } | ||
|
r4545 | } | ||
} | ||||
}); | ||||
}; | ||||
|
r12994 | |||
|
r10033 | /** | ||
|
r14085 | * Execute or render cell outputs and go into command mode. | ||
|
r10033 | * | ||
|
r14085 | * @method execute_cell | ||
|
r10033 | */ | ||
|
r14085 | Notebook.prototype.execute_cell = function () { | ||
|
r14015 | // mode = shift, ctrl, alt | ||
|
r14085 | var cell = this.get_selected_cell(); | ||
var cell_index = this.find_cell_index(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. | ||||
* | ||||
* @method execute_cell_and_insert_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. | ||||
* | ||||
* @method execute_cell_and_select_below | ||||
*/ | ||||
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. | ||||
* | ||||
* @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) { | ||
|
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. | ||||
* | ||||
* @method get_notebook_name | ||||
|
r15234 | * @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. | ||||
* | ||||
* @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 || ''; | ||||
|
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). | ||||
* | ||||
* This currently handles one worksheet: others are deleted. | ||||
* | ||||
* @method fromJSON | ||||
* @param {Object} data JSON representation of a notebook | ||||
*/ | ||||
|
r4352 | Notebook.prototype.fromJSON = function (data) { | ||
|
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. | ||
this.delete_cell(0); | ||||
|
r15236 | } | ||
|
r6047 | // Save the metadata and name. | ||
|
r13032 | this.metadata = content.metadata; | ||
this.notebook_name = data.name; | ||||
|
r15657 | var trusted = true; | ||
|
r4484 | // Only handle 1 worksheet for now. | ||
|
r13032 | var worksheet = content.worksheets[0]; | ||
|
r4484 | 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 | |||
|
r14016 | new_cell = this.insert_cell_at_index(cell_data.cell_type, i); | ||
|
r5945 | new_cell.fromJSON(cell_data); | ||
|
r15657 | if (new_cell.cell_type == 'code' && !new_cell.output_area.trusted) { | ||
trusted = false; | ||||
} | ||||
|
r15236 | } | ||
} | ||||
|
r15657 | if (trusted != this.trusted) { | ||
this.trusted = trusted; | ||||
$([IPython.events]).trigger("trust_changed.Notebook", trusted); | ||||
} | ||||
|
r13032 | if (content.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); | ||
|
r15657 | var trusted = true; | ||
|
r4352 | for (var i=0; i<ncells; i++) { | ||
|
r15657 | var cell = cells[i]; | ||
if (cell.cell_type == 'code' && !cell.output_area.trusted) { | ||||
trusted = false; | ||||
} | ||||
cell_array[i] = cell.toJSON(); | ||||
|
r15236 | } | ||
|
r7179 | var data = { | ||
|
r4484 | // Only handle 1 worksheet for now. | ||
|
r7523 | worksheets : [{ | ||
cells: cell_array, | ||||
metadata: this.worksheet_metadata | ||||
}], | ||||
|
r4637 | metadata : this.metadata | ||
|
r5479 | }; | ||
|
r15657 | if (trusted != this.trusted) { | ||
this.trusted = trusted; | ||||
$([IPython.events]).trigger("trust_changed.Notebook", trusted); | ||||
} | ||||
|
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"); | ||||
|
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 | * | ||
* @method save_notebook | ||||
*/ | ||||
|
r13076 | Notebook.prototype.save_notebook = function (extra_settings) { | ||
|
r13032 | // Create a JSON model to be sent to the server. | ||
|
r13072 | var model = {}; | ||
model.name = this.notebook_name; | ||||
model.path = this.notebook_path; | ||||
model.content = this.toJSON(); | ||||
|
r13032 | model.content.nbformat = this.nbformat; | ||
model.content.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", | ||||
|
r13032 | data : JSON.stringify(model), | ||
|
r5958 | headers : {'Content-Type': 'application/json'}, | ||
|
r10505 | success : $.proxy(this.save_notebook_success, this, start), | ||
error : $.proxy(this.save_notebook_error, this) | ||||
|
r4352 | }; | ||
|
r13076 | if (extra_settings) { | ||
for (var key in extra_settings) { | ||||
settings[key] = extra_settings[key]; | ||||
} | ||||
} | ||||
|
r6047 | $([IPython.events]).trigger('notebook_saving.Notebook'); | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r13693 | this.notebook_path, | ||
|
r13063 | this.notebook_name | ||
); | ||||
|
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; | ||||
|
r15236 | } | ||
|
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 | ||||
|
r13858 | * @param {String} error HTTP error message | ||
|
r10033 | */ | ||
|
r13858 | Notebook.prototype.save_notebook_error = function (xhr, status, error) { | ||
$([IPython.events]).trigger('notebook_save_failed.Notebook', [xhr, status, error]); | ||||
|
r5479 | }; | ||
|
r12997 | |||
|
r15655 | /** | ||
* Explicitly trust the output of this notebook. | ||||
* | ||||
* @method trust_notebook | ||||
*/ | ||||
Notebook.prototype.trust_notebook = function (extra_settings) { | ||||
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; | ||||
IPython.dialog.modal({ | ||||
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]; | ||||
if (cell.cell_type == 'code') { | ||||
cell.output_area.trusted = true; | ||||
} | ||||
} | ||||
$([IPython.events]).on('notebook_saved.Notebook', function () { | ||||
window.location.reload(); | ||||
}); | ||||
nb.save_notebook(); | ||||
|
r15655 | } | ||
} | ||||
} | ||||
}); | ||||
}; | ||||
|
r13016 | Notebook.prototype.new_notebook = function(){ | ||
|
r13693 | var path = this.notebook_path; | ||
|
r15238 | var base_url = this.base_url; | ||
|
r13016 | var settings = { | ||
processData : false, | ||||
cache : false, | ||||
type : "POST", | ||||
dataType : "json", | ||||
|
r13075 | async : false, | ||
success : function (data, status, xhr){ | ||||
|
r13032 | var notebook_name = data.name; | ||
|
r13063 | window.open( | ||
|
r13693 | utils.url_join_encode( | ||
|
r15238 | base_url, | ||
|
r13063 | 'notebooks', | ||
|
r13075 | path, | ||
|
r13063 | notebook_name | ||
), | ||||
'_blank' | ||||
); | ||||
|
r16445 | }, | ||
error : utils.log_ajax_error, | ||||
|
r13016 | }; | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | base_url, | ||
|
r13075 | 'api/notebooks', | ||
path | ||||
); | ||||
|
r13016 | $.ajax(url,settings); | ||
}; | ||||
|
r13032 | |||
|
r13017 | Notebook.prototype.copy_notebook = function(){ | ||
|
r13693 | var path = this.notebook_path; | ||
|
r15238 | var base_url = this.base_url; | ||
|
r13017 | var settings = { | ||
processData : false, | ||||
cache : false, | ||||
type : "POST", | ||||
|
r13075 | dataType : "json", | ||
|
r13139 | data : JSON.stringify({copy_from : this.notebook_name}), | ||
|
r13075 | async : false, | ||
success : function (data, status, xhr) { | ||||
|
r13693 | window.open(utils.url_join_encode( | ||
|
r15238 | base_url, | ||
|
r13063 | 'notebooks', | ||
|
r13139 | data.path, | ||
data.name | ||||
|
r13075 | ), '_blank'); | ||
|
r16445 | }, | ||
error : utils.log_ajax_error, | ||||
|
r13017 | }; | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | base_url, | ||
|
r13074 | 'api/notebooks', | ||
|
r13139 | path | ||
|
r13063 | ); | ||
|
r13017 | $.ajax(url,settings); | ||
}; | ||||
|
r12997 | |||
|
r13133 | Notebook.prototype.rename = function (nbname) { | ||
|
r12997 | var that = this; | ||
|
r15237 | if (!nbname.match(/\.ipynb$/)) { | ||
nbname = nbname + ".ipynb"; | ||||
} | ||||
var data = {name: nbname}; | ||||
|
r12997 | var settings = { | ||
processData : false, | ||||
cache : false, | ||||
type : "PATCH", | ||||
|
r13133 | data : JSON.stringify(data), | ||
|
r12997 | dataType: "json", | ||
headers : {'Content-Type': 'application/json'}, | ||||
|
r13018 | success : $.proxy(that.rename_success, this), | ||
error : $.proxy(that.rename_error, this) | ||||
|
r12997 | }; | ||
|
r13133 | $([IPython.events]).trigger('rename_notebook.Notebook', data); | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r13693 | this.notebook_path, | ||
|
r13063 | this.notebook_name | ||
); | ||||
|
r12997 | $.ajax(url, settings); | ||
}; | ||||
|
r14965 | |||
|
r14978 | Notebook.prototype.delete = function () { | ||
|
r14965 | var that = this; | ||
var settings = { | ||||
processData : false, | ||||
cache : false, | ||||
type : "DELETE", | ||||
dataType: "json", | ||||
|
r16445 | error : utils.log_ajax_error, | ||
|
r14965 | }; | ||
var url = utils.url_join_encode( | ||||
|
r15238 | this.base_url, | ||
|
r14965 | 'api/notebooks', | ||
this.notebook_path, | ||||
this.notebook_name | ||||
); | ||||
$.ajax(url, settings); | ||||
}; | ||||
|
r10501 | |||
|
r12997 | Notebook.prototype.rename_success = function (json, status, xhr) { | ||
|
r15236 | var name = this.notebook_name = json.name; | ||
|
r13693 | var path = json.path; | ||
|
r13133 | this.session.rename_notebook(name, path); | ||
$([IPython.events]).trigger('notebook_renamed.Notebook', json); | ||||
|
r15236 | }; | ||
|
r13018 | |||
|
r13858 | Notebook.prototype.rename_error = function (xhr, status, error) { | ||
|
r13018 | var that = this; | ||
var dialog = $('<div/>').append( | ||||
$("<p/>").addClass("rename-message") | ||||
|
r14634 | .text('This notebook name already exists.') | ||
|
r15236 | ); | ||
|
r13858 | $([IPython.events]).trigger('notebook_rename_failed.Notebook', [xhr, status, error]); | ||
|
r13018 | IPython.dialog.modal({ | ||
title: "Notebook Rename Error!", | ||||
body: dialog, | ||||
buttons : { | ||||
"Cancel": {}, | ||||
"OK": { | ||||
class: "btn-primary", | ||||
click: function () { | ||||
IPython.save_widget.rename_notebook(); | ||||
}} | ||||
}, | ||||
open : function (event, ui) { | ||||
var that = $(this); | ||||
// Upon ENTER, click the OK button. | ||||
that.find('input[type="text"]').keydown(function (event, ui) { | ||||
|
r15619 | if (event.which === IPython.keyboard.keycodes.enter) { | ||
|
r13018 | that.find('.btn-primary').first().click(); | ||
} | ||||
}); | ||||
that.find('input[type="text"]').focus(); | ||||
} | ||||
}); | ||||
|
r15236 | }; | ||
|
r13018 | |||
|
r10033 | /** | ||
* Request a notebook's data from the server. | ||||
* | ||||
* @method load_notebook | ||||
|
r13102 | * @param {String} notebook_name and path A notebook to load | ||
|
r10033 | */ | ||
|
r13063 | Notebook.prototype.load_notebook = function (notebook_name, notebook_path) { | ||
|
r4488 | var that = this; | ||
|
r13063 | this.notebook_name = notebook_name; | ||
this.notebook_path = notebook_path; | ||||
|
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'); | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r13693 | this.notebook_path, | ||
|
r13063 | this.notebook_name | ||
); | ||||
|
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'); | ||
|
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(); | ||
|
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 " + | ||
|
r15236 | "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 | |||
|
r12986 | // Create the session after the notebook is completely loaded to prevent | ||
|
r7197 | // code execution upon loading, which is a security risk. | ||
|
r15236 | if (this.session === null) { | ||
|
r13032 | this.start_session(); | ||
|
r12986 | } | ||
|
r11644 | // load our checkpoint list | ||
|
r13679 | this.list_checkpoints(); | ||
// load toolbar state | ||||
if (this.metadata.celltoolbar) { | ||||
IPython.CellToolbar.global_show(); | ||||
IPython.CellToolbar.activate_preset(this.metadata.celltoolbar); | ||||
|
r16534 | } else { | ||
IPython.CellToolbar.global_hide(); | ||||
|
r13679 | } | ||
|
r15881 | |||
// now that we're fully loaded, it is safe to restore save functionality | ||||
delete(this.save_notebook); | ||||
|
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 | ||||
|
r13858 | * @param {String} status Description of response status | ||
* @param {String} error HTTP error message | ||||
|
r10033 | */ | ||
|
r13858 | Notebook.prototype.load_notebook_error = function (xhr, status, error) { | ||
$([IPython.events]).trigger('notebook_load_failed.Notebook', [xhr, status, error]); | ||||
|
r15236 | var msg; | ||
|
r11643 | if (xhr.status === 400) { | ||
|
r15236 | msg = error; | ||
|
r11643 | } else if (xhr.status === 500) { | ||
|
r15236 | msg = "An unknown error occurred while loading this notebook. " + | ||
|
r11643 | "This version can load notebook formats " + | ||
"v" + this.nbformat + " or earlier."; | ||||
|
r6061 | } | ||
|
r11643 | IPython.dialog.modal({ | ||
title: "Error loading notebook", | ||||
body : msg, | ||||
buttons : { | ||||
"OK": {} | ||||
} | ||||
}); | ||||
|
r15236 | }; | ||
|
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]; | ||||
|
r13122 | 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. | ||
* | ||||
|
r12050 | * @method list_checkpoints | ||
|
r10501 | */ | ||
Notebook.prototype.list_checkpoints = function () { | ||||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r13693 | this.notebook_path, | ||
|
r13063 | this.notebook_name, | ||
'checkpoints' | ||||
); | ||||
|
r10501 | $.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) { | ||||
|
r15236 | 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 () { | ||||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r15234 | this.notebook_path, | ||
|
r13063 | this.notebook_name, | ||
'checkpoints' | ||||
); | ||||
|
r10501 | $.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) { | ||||
|
r15236 | 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; | ||
|
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 | ); | ||
|
r10895 | IPython.dialog.modal({ | ||
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. | ||||
* | ||||
* @method restore_checkpoint | ||||
* @param {String} checkpoint ID | ||||
*/ | ||||
Notebook.prototype.restore_checkpoint = function (checkpoint) { | ||||
|
r12992 | $([IPython.events]).trigger('notebook_restoring.Notebook', checkpoint); | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r15234 | this.notebook_path, | ||
|
r13063 | this.notebook_name, | ||
'checkpoints', | ||||
checkpoint | ||||
); | ||||
|
r10501 | $.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'); | ||||
|
r12986 | this.load_notebook(this.notebook_name, this.notebook_path); | ||
|
r10501 | }; | ||
/** | ||||
* 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) { | ||||
|
r12992 | $([IPython.events]).trigger('notebook_restoring.Notebook', checkpoint); | ||
|
r13693 | var url = utils.url_join_encode( | ||
|
r15238 | this.base_url, | ||
|
r13063 | 'api/notebooks', | ||
|
r15234 | this.notebook_path, | ||
|
r13063 | this.notebook_name, | ||
'checkpoints', | ||||
checkpoint | ||||
); | ||||
|
r10501 | $.ajax(url, { | ||
type: 'DELETE', | ||||
success: $.proxy(this.delete_checkpoint_success, this), | ||||
|
r16475 | error: $.proxy(this.delete_checkpoint_error, this) | ||
|
r10501 | }); | ||
}; | ||||
/** | ||||
* 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); | ||||
|
r12986 | this.load_notebook(this.notebook_name, this.notebook_path); | ||
|
r10501 | }; | ||
/** | ||||
* 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)); | ||||
|
r15497 | |||