cell.js
692 lines
| 21.1 KiB
| application/javascript
|
JavascriptLexer
|
r17196 | // Copyright (c) IPython Development Team. | ||
// Distributed under the terms of the Modified BSD License. | ||||
|
r18280 | /** | ||
* | ||||
* | ||||
* @module cell | ||||
* @namespace cell | ||||
* @class Cell | ||||
*/ | ||||
|
r17196 | define([ | ||
'base/js/namespace', | ||||
|
r17200 | 'jquery', | ||
|
r17196 | 'base/js/utils', | ||
|
r18280 | 'codemirror/lib/codemirror', | ||
'codemirror/addon/edit/matchbrackets', | ||||
'codemirror/addon/edit/closebrackets', | ||||
'codemirror/addon/comment/comment' | ||||
|
r18287 | ], function(IPython, $, utils, CodeMirror, cm_match, cm_closeb, cm_comment) { | ||
|
r17421 | // TODO: remove IPython dependency here | ||
|
r12103 | "use strict"; | ||
|
r20298 | |||
var overlayHack = CodeMirror.scrollbarModel.native.prototype.overlayHack; | ||||
CodeMirror.scrollbarModel.native.prototype.overlayHack = function () { | ||||
overlayHack.apply(this, arguments); | ||||
// Reverse `min-height: 18px` scrollbar hack on OS X | ||||
// which causes a dead area, making it impossible to click on the last line | ||||
// when there is horizontal scrolling to do and the "show scrollbar only when scrolling" behavior | ||||
// is enabled. | ||||
// This, in turn, has the undesirable behavior of never showing the horizontal scrollbar, | ||||
// even when it should, which is less problematic, at least. | ||||
if (/Mac/.test(navigator.platform)) { | ||||
this.horiz.style.minHeight = ""; | ||||
} | ||||
}; | ||||
|
r17210 | var Cell = function (options) { | ||
|
r18280 | /* Constructor | ||
* | ||||
* The Base `Cell` class from which to inherit. | ||||
* @constructor | ||||
* @param: | ||||
* options: dictionary | ||||
* Dictionary of keyword arguments. | ||||
|
r18289 | * events: $(Events) instance | ||
|
r18280 | * config: dictionary | ||
|
r18289 | * keyboard_manager: KeyboardManager instance | ||
|
r18280 | */ | ||
|
r17210 | options = options || {}; | ||
this.keyboard_manager = options.keyboard_manager; | ||||
this.events = options.events; | ||||
|
r17764 | var config = utils.mergeopt(Cell, options.config); | ||
|
r9537 | // superclass default overwrite our default | ||
|
r13668 | |||
|
r17210 | this.placeholder = config.placeholder || ''; | ||
this.read_only = config.cm_config.readOnly; | ||||
|
r4352 | this.selected = false; | ||
|
r14014 | this.rendered = false; | ||
this.mode = 'command'; | ||||
|
r18854 | |||
// Metadata property | ||||
var that = this; | ||||
this._metadata = {}; | ||||
Object.defineProperty(this, 'metadata', { | ||||
get: function() { return that._metadata; }, | ||||
set: function(value) { | ||||
that._metadata = value; | ||||
|
r18999 | if (that.celltoolbar) { | ||
that.celltoolbar.rebuild(); | ||||
} | ||||
|
r18854 | } | ||
}); | ||||
|
r8202 | // load this from metadata later ? | ||
|
r8839 | this.user_highlight = 'auto'; | ||
|
r17210 | this.cm_config = config.cm_config; | ||
|
r17198 | this.cell_id = utils.uuid(); | ||
|
r17210 | this._options = config; | ||
|
r13574 | |||
|
r15495 | // For JS VM engines optimization, attributes should be all set (even | ||
|
r13574 | // to null) in the constructor, and if possible, if different subclass | ||
// have new attributes with same name, they should be created in the | ||||
// same order. Easiest is to create and set to null in parent class. | ||||
this.element = null; | ||||
|
r13676 | this.cell_type = this.cell_type || null; | ||
|
r13574 | this.code_mirror = null; | ||
|
r4352 | this.create_element(); | ||
|
r4529 | if (this.element !== null) { | ||
|
r4352 | this.element.data("cell", this); | ||
this.bind_events(); | ||||
|
r14049 | this.init_classes(); | ||
|
r4352 | } | ||
}; | ||||
|
r10165 | Cell.options_default = { | ||
cm_config : { | ||||
|
r9537 | indentUnit : 4, | ||
|
r10165 | readOnly: false, | ||
|
r16596 | theme: "default", | ||
extraKeys: { | ||||
"Cmd-Right":"goLineRight", | ||||
"End":"goLineRight", | ||||
"Cmd-Left":"goLineLeft" | ||||
} | ||||
|
r10165 | } | ||
|
r9537 | }; | ||
|
r10791 | |||
// FIXME: Workaround CM Bug #332 (Safari segfault on drag) | ||||
// by disabling drag/drop altogether on Safari | ||||
|
r17940 | // https://github.com/codemirror/CodeMirror/issues/332 | ||
|
r17198 | if (utils.browser[0] == "Safari") { | ||
|
r10791 | Cell.options_default.cm_config.dragDrop = false; | ||
} | ||||
|
r9537 | |||
|
r8713 | /** | ||
* Empty. Subclasses must implement create_element. | ||||
|
r8714 | * This should contain all the code to create the DOM element in notebook | ||
|
r8713 | * and will be called by Base Class constructor. | ||
* @method create_element | ||||
*/ | ||||
|
r9073 | Cell.prototype.create_element = function () { | ||
}; | ||||
|
r4352 | |||
|
r14049 | Cell.prototype.init_classes = function () { | ||
|
r19176 | /** | ||
* Call after this.element exists to initialize the css classes | ||||
* related to selected, rendered and mode. | ||||
*/ | ||||
|
r14049 | if (this.selected) { | ||
this.element.addClass('selected'); | ||||
} else { | ||||
this.element.addClass('unselected'); | ||||
} | ||||
if (this.rendered) { | ||||
this.element.addClass('rendered'); | ||||
} else { | ||||
this.element.addClass('unrendered'); | ||||
} | ||||
|
r15493 | }; | ||
|
r14049 | |||
|
r8713 | /** | ||
|
r8714 | * Subclasses can implement override bind_events. | ||
* Be carefull to call the parent method when overwriting as it fires event. | ||||
* this will be triggerd after create_element in constructor. | ||||
|
r8713 | * @method bind_events | ||
*/ | ||||
|
r4352 | Cell.prototype.bind_events = function () { | ||
var that = this; | ||||
|
r7168 | // We trigger events so that Cell doesn't have to depend on Notebook. | ||
|
r4352 | that.element.click(function (event) { | ||
|
r14033 | if (!that.selected) { | ||
|
r17196 | that.events.trigger('select.Cell', {'cell':that}); | ||
|
r15493 | } | ||
|
r4352 | }); | ||
that.element.focusin(function (event) { | ||||
|
r14033 | if (!that.selected) { | ||
|
r17196 | that.events.trigger('select.Cell', {'cell':that}); | ||
|
r15493 | } | ||
|
r14016 | }); | ||
|
r10785 | if (this.code_mirror) { | ||
this.code_mirror.on("change", function(cm, change) { | ||||
|
r17196 | that.events.trigger("set_dirty.Notebook", {value: true}); | ||
|
r10785 | }); | ||
|
r14092 | } | ||
|
r14015 | if (this.code_mirror) { | ||
this.code_mirror.on('focus', function(cm, change) { | ||||
|
r17196 | that.events.trigger('edit_mode.Cell', {cell: that}); | ||
|
r14015 | }); | ||
|
r14092 | } | ||
|
r14033 | if (this.code_mirror) { | ||
this.code_mirror.on('blur', function(cm, change) { | ||||
|
r17196 | that.events.trigger('command_mode.Cell', {cell: that}); | ||
|
r14033 | }); | ||
|
r14092 | } | ||
|
r18270 | |||
this.element.dblclick(function () { | ||||
if (that.selected === false) { | ||||
this.events.trigger('select.Cell', {'cell':that}); | ||||
} | ||||
var cont = that.unrender(); | ||||
if (cont) { | ||||
that.focus_editor(); | ||||
} | ||||
}); | ||||
|
r4352 | }; | ||
|
r15757 | |||
/** | ||||
* This method gets called in CodeMirror's onKeyDown/onKeyPress | ||||
* handlers and is used to provide custom key handling. | ||||
* | ||||
* To have custom handling, subclasses should override this method, but still call it | ||||
* in order to process the Edit mode keyboard shortcuts. | ||||
* | ||||
* @method handle_codemirror_keyevent | ||||
* @param {CodeMirror} editor - The codemirror instance bound to the cell | ||||
|
r15820 | * @param {event} event - key press event which either should or should not be handled by CodeMirror | ||
|
r15757 | * @return {Boolean} `true` if CodeMirror should ignore the event, `false` Otherwise | ||
*/ | ||||
Cell.prototype.handle_codemirror_keyevent = function (editor, event) { | ||||
|
r17196 | var shortcuts = this.keyboard_manager.edit_shortcuts; | ||
|
r15757 | |||
|
r18282 | var cur = editor.getCursor(); | ||
if((cur.line !== 0 || cur.ch !==0) && event.keyCode === 38){ | ||||
event._ipkmIgnore = true; | ||||
} | ||||
|
r18999 | var nLastLine = editor.lastLine(); | ||
if ((event.keyCode === 40) && | ||||
((cur.line !== nLastLine) || | ||||
(cur.ch !== editor.getLineHandle(nLastLine).text.length)) | ||||
) { | ||||
|
r18282 | event._ipkmIgnore = true; | ||
} | ||||
|
r15822 | // if this is an edit_shortcuts shortcut, the global keyboard/shortcut | ||
// manager will handle it | ||||
|
r18289 | if (shortcuts.handles(event)) { | ||
return true; | ||||
|
r18282 | } | ||
|
r15758 | |||
|
r15757 | return false; | ||
}; | ||||
|
r4352 | |||
|
r8714 | /** | ||
* Triger typsetting of math by mathjax on current cell element | ||||
* @method typeset | ||||
*/ | ||||
|
r8660 | Cell.prototype.typeset = function () { | ||
|
r19235 | utils.typeset(this.element); | ||
|
r8660 | }; | ||
|
r5959 | |||
|
r8714 | /** | ||
|
r14013 | * handle cell level logic when a cell is selected | ||
|
r8714 | * @method select | ||
|
r14014 | * @return is the action being taken | ||
|
r8714 | */ | ||
|
r5943 | Cell.prototype.select = function () { | ||
|
r14014 | if (!this.selected) { | ||
this.element.addClass('selected'); | ||||
this.element.removeClass('unselected'); | ||||
this.selected = true; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r5943 | }; | ||
|
r8714 | /** | ||
|
r14013 | * handle cell level logic when a cell is unselected | ||
|
r8714 | * @method unselect | ||
|
r14014 | * @return is the action being taken | ||
|
r8714 | */ | ||
|
r5943 | Cell.prototype.unselect = function () { | ||
|
r14014 | if (this.selected) { | ||
this.element.addClass('unselected'); | ||||
this.element.removeClass('selected'); | ||||
this.selected = false; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r5943 | }; | ||
|
r8739 | /** | ||
|
r18999 | * should be overritten by subclass | ||
* @method execute | ||||
*/ | ||||
Cell.prototype.execute = function () { | ||||
return; | ||||
}; | ||||
/** | ||||
|
r14014 | * handle cell level logic when a cell is rendered | ||
* @method render | ||||
* @return is the action being taken | ||||
|
r14013 | */ | ||
|
r14014 | Cell.prototype.render = function () { | ||
if (!this.rendered) { | ||||
this.element.addClass('rendered'); | ||||
this.element.removeClass('unrendered'); | ||||
this.rendered = true; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r14013 | }; | ||
/** | ||||
|
r14014 | * handle cell level logic when a cell is unrendered | ||
* @method unrender | ||||
* @return is the action being taken | ||||
|
r14013 | */ | ||
|
r14014 | Cell.prototype.unrender = function () { | ||
if (this.rendered) { | ||||
this.element.addClass('unrendered'); | ||||
this.element.removeClass('rendered'); | ||||
this.rendered = false; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r14013 | }; | ||
/** | ||||
|
r15822 | * Delegates keyboard shortcut handling to either IPython keyboard | ||
|
r15755 | * manager when in command mode, or CodeMirror when in edit mode | ||
* | ||||
* @method handle_keyevent | ||||
* @param {CodeMirror} editor - The codemirror instance bound to the cell | ||||
|
r15838 | * @param {event} - key event to be handled | ||
|
r15755 | * @return {Boolean} `true` if CodeMirror should ignore the event, `false` Otherwise | ||
*/ | ||||
|
r15756 | Cell.prototype.handle_keyevent = function (editor, event) { | ||
|
r15755 | if (this.mode === 'command') { | ||
return true; | ||||
} else if (this.mode === 'edit') { | ||||
return this.handle_codemirror_keyevent(editor, event); | ||||
} | ||||
}; | ||||
/** | ||||
|
r15754 | * @method at_top | ||
* @return {Boolean} | ||||
*/ | ||||
Cell.prototype.at_top = function () { | ||||
|
r15819 | var cm = this.code_mirror; | ||
|
r15754 | var cursor = cm.getCursor(); | ||
|
r15835 | if (cursor.line === 0 && cursor.ch === 0) { | ||
|
r15754 | return true; | ||
} | ||||
|
r15836 | return false; | ||
|
r15754 | }; | ||
/** | ||||
* @method at_bottom | ||||
* @return {Boolean} | ||||
* */ | ||||
Cell.prototype.at_bottom = function () { | ||||
|
r15819 | var cm = this.code_mirror; | ||
|
r15754 | var cursor = cm.getCursor(); | ||
|
r15835 | if (cursor.line === (cm.lineCount()-1) && cursor.ch === cm.getLine(cursor.line).length) { | ||
|
r15754 | return true; | ||
} | ||||
|
r15836 | return false; | ||
|
r15754 | }; | ||
|
r15836 | |||
|
r15754 | /** | ||
|
r14014 | * enter the command mode for the cell | ||
* @method command_mode | ||||
* @return is the action being taken | ||||
*/ | ||||
Cell.prototype.command_mode = function () { | ||||
if (this.mode !== 'command') { | ||||
this.mode = 'command'; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r14014 | }; | ||
/** | ||||
* enter the edit mode for the cell | ||||
* @method command_mode | ||||
* @return is the action being taken | ||||
*/ | ||||
Cell.prototype.edit_mode = function () { | ||||
if (this.mode !== 'edit') { | ||||
this.mode = 'edit'; | ||||
return true; | ||||
} else { | ||||
return false; | ||||
|
r14092 | } | ||
|
r15493 | }; | ||
|
r15777 | |||
|
r15495 | /** | ||
|
r14014 | * Focus the cell in the DOM sense | ||
* @method focus_cell | ||||
*/ | ||||
Cell.prototype.focus_cell = function () { | ||||
this.element.focus(); | ||||
|
r15493 | }; | ||
|
r14014 | |||
/** | ||||
|
r15497 | * Focus the editor area so a user can type | ||
* | ||||
* NOTE: If codemirror is focused via a mouse click event, you don't want to | ||||
* call this because it will cause a page jump. | ||||
* @method focus_editor | ||||
*/ | ||||
Cell.prototype.focus_editor = function () { | ||||
|
r15540 | this.refresh(); | ||
|
r15497 | this.code_mirror.focus(); | ||
}; | ||||
/** | ||||
|
r8739 | * Refresh codemirror instance | ||
* @method refresh | ||||
*/ | ||||
|
r5943 | Cell.prototype.refresh = function () { | ||
|
r18999 | if (this.code_mirror) { | ||
this.code_mirror.refresh(); | ||||
} | ||||
|
r5943 | }; | ||
|
r8739 | /** | ||
* should be overritten by subclass | ||||
|
r14015 | * @method get_text | ||
*/ | ||||
Cell.prototype.get_text = function () { | ||||
|
r5943 | }; | ||
|
r8739 | /** | ||
* should be overritten by subclass | ||||
|
r14015 | * @method set_text | ||
* @param {string} text | ||||
*/ | ||||
Cell.prototype.set_text = function (text) { | ||||
|
r5943 | }; | ||
|
r8739 | /** | ||
* should be overritten by subclass | ||||
* serialise cell to json. | ||||
* @method toJSON | ||||
**/ | ||||
|
r5943 | Cell.prototype.toJSON = function () { | ||
|
r7523 | var data = {}; | ||
|
r17998 | // deepcopy the metadata so copied cells don't share the same object | ||
data.metadata = JSON.parse(JSON.stringify(this.metadata)); | ||||
|
r13676 | data.cell_type = this.cell_type; | ||
|
r7523 | return data; | ||
|
r5943 | }; | ||
|
r8739 | /** | ||
* should be overritten by subclass | ||||
* @method fromJSON | ||||
**/ | ||||
|
r5943 | Cell.prototype.fromJSON = function (data) { | ||
|
r7523 | if (data.metadata !== undefined) { | ||
|
r18854 | this.metadata = data.metadata; | ||
|
r7523 | } | ||
|
r5943 | }; | ||
|
r8739 | /** | ||
|
r17998 | * can the cell be split into two cells (false if not deletable) | ||
|
r8739 | * @method is_splittable | ||
**/ | ||||
|
r5946 | Cell.prototype.is_splittable = function () { | ||
|
r17998 | return this.is_deletable(); | ||
|
r5946 | }; | ||
|
r8739 | /** | ||
|
r17998 | * can the cell be merged with other cells (false if not deletable) | ||
|
r12509 | * @method is_mergeable | ||
**/ | ||||
Cell.prototype.is_mergeable = function () { | ||||
|
r17998 | return this.is_deletable(); | ||
|
r12509 | }; | ||
|
r17998 | /** | ||
|
r18000 | * is the cell deletable? only false (undeletable) if | ||
* metadata.deletable is explicitly false -- everything else | ||||
* counts as true | ||||
* | ||||
|
r17998 | * @method is_deletable | ||
**/ | ||||
Cell.prototype.is_deletable = function () { | ||||
|
r18000 | if (this.metadata.deletable === false) { | ||
return false; | ||||
|
r17998 | } | ||
|
r18000 | return true; | ||
|
r17998 | }; | ||
|
r12509 | |||
/** | ||||
|
r8739 | * @return {String} - the text before the cursor | ||
* @method get_pre_cursor | ||||
**/ | ||||
|
r5946 | Cell.prototype.get_pre_cursor = function () { | ||
var cursor = this.code_mirror.getCursor(); | ||||
|
r10165 | var text = this.code_mirror.getRange({line:0, ch:0}, cursor); | ||
|
r5946 | text = text.replace(/^\n+/, '').replace(/\n+$/, ''); | ||
return text; | ||||
|
r15497 | }; | ||
|
r5946 | |||
|
r8739 | /** | ||
* @return {String} - the text after the cursor | ||||
* @method get_post_cursor | ||||
**/ | ||||
|
r5946 | Cell.prototype.get_post_cursor = function () { | ||
var cursor = this.code_mirror.getCursor(); | ||||
var last_line_num = this.code_mirror.lineCount()-1; | ||||
var last_line_len = this.code_mirror.getLine(last_line_num).length; | ||||
|
r15497 | var end = {line:last_line_num, ch:last_line_len}; | ||
|
r5946 | var text = this.code_mirror.getRange(cursor, end); | ||
text = text.replace(/^\n+/, '').replace(/\n+$/, ''); | ||||
return text; | ||||
}; | ||||
|
r8739 | /** | ||
|
r9542 | * Show/Hide CodeMirror LineNumber | ||
|
r9690 | * @method show_line_numbers | ||
|
r9542 | * | ||
* @param value {Bool} show (true), or hide (false) the line number in CodeMirror | ||||
**/ | ||||
Cell.prototype.show_line_numbers = function (value) { | ||||
this.code_mirror.setOption('lineNumbers', value); | ||||
this.code_mirror.refresh(); | ||||
}; | ||||
/** | ||||
|
r8739 | * Toggle CodeMirror LineNumber | ||
* @method toggle_line_numbers | ||||
**/ | ||||
|
r6059 | Cell.prototype.toggle_line_numbers = function () { | ||
|
r9690 | var val = this.code_mirror.getOption('lineNumbers'); | ||
this.show_line_numbers(!val); | ||||
|
r6059 | }; | ||
|
r8739 | /** | ||
|
r9548 | * Force codemirror highlight mode | ||
|
r8739 | * @method force_highlight | ||
* @param {object} - CodeMirror mode | ||||
**/ | ||||
|
r8202 | Cell.prototype.force_highlight = function(mode) { | ||
this.user_highlight = mode; | ||||
this.auto_highlight(); | ||||
}; | ||||
|
r19894 | |||
/** | ||||
* Trigger autodetection of highlight scheme for current cell | ||||
* @method auto_highlight | ||||
*/ | ||||
Cell.prototype.auto_highlight = function () { | ||||
this._auto_highlight(this.class_config.get_sync('highlight_modes')); | ||||
}; | ||||
|
r8739 | /** | ||
* Try to autodetect cell highlight mode, or use selected mode | ||||
* @methods _auto_highlight | ||||
* @private | ||||
* @param {String|object|undefined} - CodeMirror mode | 'auto' | ||||
**/ | ||||
|
r8202 | Cell.prototype._auto_highlight = function (modes) { | ||
|
r19176 | /** | ||
*Here we handle manually selected modes | ||||
*/ | ||||
|
r18286 | var that = this; | ||
|
r15497 | var mode; | ||
if( this.user_highlight !== undefined && this.user_highlight != 'auto' ) | ||||
|
r8202 | { | ||
|
r15497 | mode = this.user_highlight; | ||
|
r8202 | CodeMirror.autoLoadMode(this.code_mirror, mode); | ||
this.code_mirror.setOption('mode', mode); | ||||
return; | ||||
} | ||||
|
r13573 | var current_mode = this.code_mirror.getOption('mode', mode); | ||
|
r8202 | var first_line = this.code_mirror.getLine(0); | ||
// loop on every pairs | ||||
|
r15497 | for(mode in modes) { | ||
var regs = modes[mode].reg; | ||||
|
r8202 | // only one key every time but regexp can't be keys... | ||
|
r14106 | for(var i=0; i<regs.length; i++) { | ||
|
r8202 | // here we handle non magic_modes | ||
|
r15497 | if(first_line.match(regs[i]) !== null) { | ||
|
r13573 | if(current_mode == mode){ | ||
return; | ||||
} | ||||
|
r15497 | if (mode.search('magic_') !== 0) { | ||
|
r19286 | utils.requireCodeMirrorMode(mode, function (spec) { | ||
that.code_mirror.setOption('mode', spec); | ||||
|
r18286 | }); | ||
|
r8202 | return; | ||
} | ||||
|
r15497 | var open = modes[mode].open || "%%"; | ||
var close = modes[mode].close || "%%end"; | ||||
|
r18289 | var magic_mode = mode; | ||
mode = magic_mode.substr(6); | ||||
if(current_mode == magic_mode){ | ||||
|
r13573 | return; | ||
} | ||||
|
r19286 | utils.requireCodeMirrorMode(mode, function (spec) { | ||
|
r18286 | // create on the fly a mode that switch between | ||
// plain/text and something else, otherwise `%%` is | ||||
// source of some highlight issues. | ||||
|
r18289 | CodeMirror.defineMode(magic_mode, function(config) { | ||
|
r18286 | return CodeMirror.multiplexingMode( | ||
CodeMirror.getMode(config, 'text/plain'), | ||||
|
r18289 | // always set something on close | ||
|
r18286 | {open: open, close: close, | ||
|
r19286 | mode: CodeMirror.getMode(config, spec), | ||
|
r18286 | delimStyle: "delimit" | ||
} | ||||
); | ||||
}); | ||||
|
r18289 | that.code_mirror.setOption('mode', magic_mode); | ||
|
r8202 | }); | ||
return; | ||||
} | ||||
} | ||||
} | ||||
|
r12233 | // fallback on default | ||
|
r15497 | var default_mode; | ||
|
r12237 | try { | ||
default_mode = this._options.cm_config.mode; | ||||
} catch(e) { | ||||
default_mode = 'text/plain'; | ||||
} | ||||
|
r13573 | if( current_mode === default_mode){ | ||
|
r15497 | return; | ||
|
r13573 | } | ||
|
r8202 | this.code_mirror.setOption('mode', default_mode); | ||
}; | ||||
|
r6059 | |||
|
r18999 | var UnrecognizedCell = function (options) { | ||
/** Constructor for unrecognized cells */ | ||||
Cell.apply(this, arguments); | ||||
this.cell_type = 'unrecognized'; | ||||
this.celltoolbar = null; | ||||
this.data = {}; | ||||
Object.seal(this); | ||||
}; | ||||
UnrecognizedCell.prototype = Object.create(Cell.prototype); | ||||
// cannot merge or split unrecognized cells | ||||
UnrecognizedCell.prototype.is_mergeable = function () { | ||||
return false; | ||||
}; | ||||
UnrecognizedCell.prototype.is_splittable = function () { | ||||
return false; | ||||
}; | ||||
UnrecognizedCell.prototype.toJSON = function () { | ||||
|
r19176 | /** | ||
* deepcopy the metadata so copied cells don't share the same object | ||||
*/ | ||||
|
r18999 | return JSON.parse(JSON.stringify(this.data)); | ||
}; | ||||
UnrecognizedCell.prototype.fromJSON = function (data) { | ||||
this.data = data; | ||||
if (data.metadata !== undefined) { | ||||
this.metadata = data.metadata; | ||||
} else { | ||||
data.metadata = this.metadata; | ||||
} | ||||
|
r19107 | this.element.find('.inner_cell').find("a").text("Unrecognized cell type: " + data.cell_type); | ||
|
r18999 | }; | ||
UnrecognizedCell.prototype.create_element = function () { | ||||
Cell.prototype.create_element.apply(this, arguments); | ||||
var cell = this.element = $("<div>").addClass('cell unrecognized_cell'); | ||||
cell.attr('tabindex','2'); | ||||
var prompt = $('<div/>').addClass('prompt input_prompt'); | ||||
cell.append(prompt); | ||||
var inner_cell = $('<div/>').addClass('inner_cell'); | ||||
|
r19107 | inner_cell.append( | ||
$("<a>") | ||||
.attr("href", "#") | ||||
.text("Unrecognized cell type") | ||||
); | ||||
|
r18999 | cell.append(inner_cell); | ||
this.element = cell; | ||||
}; | ||||
|
r19107 | |||
UnrecognizedCell.prototype.bind_events = function () { | ||||
Cell.prototype.bind_events.apply(this, arguments); | ||||
var cell = this; | ||||
this.element.find('.inner_cell').find("a").click(function () { | ||||
|
r19894 | cell.events.trigger('unrecognized_cell.Cell', {cell: cell}); | ||
|
r19107 | }); | ||
}; | ||||
|
r18999 | |||
|
r17421 | // Backwards compatibility. | ||
|
r4352 | IPython.Cell = Cell; | ||
|
r18999 | return { | ||
Cell: Cell, | ||||
UnrecognizedCell: UnrecognizedCell | ||||
}; | ||||
|
r17196 | }); | ||