codecell.js
440 lines
| 14.7 KiB
| application/javascript
|
JavascriptLexer
|
r4609 | //---------------------------------------------------------------------------- | |
// Copyright (C) 2008-2011 The IPython Development Team | |||
// | |||
// Distributed under the terms of the BSD License. The full license is in | |||
// the file COPYING, distributed as part of this software. | |||
//---------------------------------------------------------------------------- | |||
|
r4349 | ||
//============================================================================ | |||
// CodeCell | |||
//============================================================================ | |||
|
r8768 | /** | |
* An extendable module that provide base functionnality to create cell for notebook. | |||
* @module IPython | |||
* @namespace IPython | |||
* @submodule CodeCell | |||
*/ | |||
|
r4349 | ||
|
r9515 | ||
/* local util for codemirror */ | |||
var posEq = function(a, b) {return a.line == b.line && a.ch == b.ch;} | |||
/** | |||
* | |||
* function to delete until previous non blanking space character | |||
* or first multiple of 4 tabstop. | |||
* @private | |||
*/ | |||
CodeMirror.commands.delSpaceToPrevTabStop = function(cm){ | |||
var from = cm.getCursor(true), to = cm.getCursor(false), sel = !posEq(from, to); | |||
if (!posEq(from, to)) {cm.replaceRange("", from, to); return} | |||
var cur = cm.getCursor(), line = cm.getLine(cur.line); | |||
var tabsize = cm.getOption('tabSize'); | |||
var chToPrevTabStop = cur.ch-(Math.ceil(cur.ch/tabsize)-1)*tabsize; | |||
var from = {ch:cur.ch-chToPrevTabStop,line:cur.line} | |||
var select = cm.getRange(from,cur) | |||
if( select.match(/^\ +$/) != null){ | |||
cm.replaceRange("",from,cur) | |||
} else { | |||
cm.deleteH(-1,"char") | |||
} | |||
}; | |||
|
r4352 | var IPython = (function (IPython) { | |
|
r7132 | "use strict"; | |
|
r4352 | var utils = IPython.utils; | |
|
r7136 | var key = IPython.utils.keycodes; | |
|
r4352 | ||
|
r8768 | /** | |
* A Cell conceived to write code. | |||
* | |||
* The kernel doesn't have to be set at creation time, in that case | |||
* it will be null and set_kernel has to be called later. | |||
* @class CodeCell | |||
* @extends IPython.Cell | |||
* | |||
* @constructor | |||
* @param {Object|null} kernel | |||
|
r9537 | * @param {object|undefined} [options] | |
* @param [options.cm_config] {object} config to pass to CodeMirror | |||
|
r8768 | */ | |
|
r12999 | var CodeCell = function (session, options) { | |
this.session = session || null; | |||
|
r4352 | this.code_mirror = null; | |
|
r5814 | this.input_prompt_number = null; | |
|
r7524 | this.collapsed = false; | |
|
r10910 | this.cell_type = "code"; | |
|
r9537 | ||
var cm_overwrite_options = { | |||
onKeyEvent: $.proxy(this.handle_codemirror_keyevent,this) | |||
}; | |||
|
r10165 | options = this.mergeopt(CodeCell, options, {cm_config:cm_overwrite_options}); | |
|
r9537 | ||
IPython.Cell.apply(this,[options]); | |||
|
r8202 | ||
var that = this; | |||
this.element.focusout( | |||
|
r8281 | function() { that.auto_highlight(); } | |
); | |||
|
r4352 | }; | |
|
r10165 | CodeCell.options_default = { | |
cm_config : { | |||
|
r11488 | extraKeys: { | |
"Tab" : "indentMore", | |||
"Shift-Tab" : "indentLess", | |||
"Backspace" : "delSpaceToPrevTabStop", | |||
"Cmd-/" : "toggleComment", | |||
"Ctrl-/" : "toggleComment" | |||
}, | |||
|
r10418 | mode: 'ipython', | |
|
r9537 | theme: 'ipython', | |
matchBrackets: true | |||
|
r10165 | } | |
|
r9537 | }; | |
|
r4352 | CodeCell.prototype = new IPython.Cell(); | |
|
r8768 | /** | |
* @method auto_highlight | |||
*/ | |||
|
r8202 | CodeCell.prototype.auto_highlight = function () { | |
this._auto_highlight(IPython.config.cell_magic_highlight) | |||
}; | |||
|
r8768 | /** @method create_element */ | |
|
r4352 | CodeCell.prototype.create_element = function () { | |
|
r9073 | IPython.Cell.prototype.create_element.apply(this, arguments); | |
|
r9055 | ||
|
r10217 | var cell = $('<div></div>').addClass('cell border-box-sizing code_cell'); | |
|
r4629 | cell.attr('tabindex','2'); | |
|
r9142 | ||
this.celltoolbar = new IPython.CellToolbar(this); | |||
|
r10215 | var input = $('<div></div>').addClass('input'); | |
|
r9422 | var vbox = $('<div/>').addClass('vbox box-flex1') | |
|
r4379 | input.append($('<div/>').addClass('prompt input_prompt')); | |
|
r9422 | vbox.append(this.celltoolbar.element); | |
var input_area = $('<div/>').addClass('input_area'); | |||
|
r9537 | this.code_mirror = CodeMirror(input_area.get(0), this.cm_config); | |
|
r10065 | $(this.code_mirror.getInputField()).attr("spellcheck", "false"); | |
|
r9422 | vbox.append(input_area); | |
input.append(vbox); | |||
|
r7177 | var output = $('<div></div>'); | |
|
r4352 | cell.append(input).append(output); | |
this.element = cell; | |||
|
r7205 | this.output_area = new IPython.OutputArea(output, true); | |
|
r7132 | ||
|
r7166 | // construct a completer only if class exist | |
// otherwise no print view | |||
|
r7197 | if (IPython.Completer !== undefined) | |
|
r7166 | { | |
|
r7171 | this.completer = new IPython.Completer(this); | |
|
r7166 | } | |
|
r4352 | }; | |
|
r8768 | /** | |
* This method gets called in CodeMirror's onKeyDown/onKeyPress | |||
* handlers and is used to provide custom key handling. Its return | |||
* value is used to determine if CodeMirror should ignore the event: | |||
* true = ignore, false = don't ignore. | |||
* @method handle_codemirror_keyevent | |||
*/ | |||
|
r4378 | CodeCell.prototype.handle_codemirror_keyevent = function (editor, event) { | |
|
r7339 | ||
|
r5398 | var that = this; | |
|
r5397 | // whatever key is pressed, first, cancel the tooltip request before | |
|
r7160 | // they are sent, and remove tooltip if any, except for tab again | |
|
r7193 | if (event.type === 'keydown' && event.which != key.TAB ) { | |
|
r7151 | IPython.tooltip.remove_and_cancel_tooltip(); | |
|
r6059 | }; | |
|
r7168 | var cur = editor.getCursor(); | |
|
r8202 | if (event.keyCode === key.ENTER){ | |
this.auto_highlight(); | |||
} | |||
|
r6059 | ||
|
r7193 | if (event.keyCode === key.ENTER && (event.shiftKey || event.ctrlKey)) { | |
|
r4378 | // Always ignore shift-enter in CodeMirror as we handle it. | |
return true; | |||
|
r7168 | } else if (event.which === 40 && event.type === 'keypress' && IPython.tooltip.time_before_tooltip >= 0) { | |
|
r7160 | // triger on keypress (!) otherwise inconsistent event.which depending on plateform | |
|
r5403 | // browser and keyboard layout ! | |
|
r5399 | // Pressing '(' , request tooltip, don't forget to reappend it | |
|
r12458 | // The second argument says to hide the tooltip if the docstring | |
|
r11715 | // is actually empty | |
IPython.tooltip.pending(that, true); | |||
|
r7199 | } else if (event.which === key.UPARROW && event.type === 'keydown') { | |
|
r5944 | // If we are not at the top, let CM handle the up arrow and | |
// prevent the global keydown handler from handling it. | |||
if (!that.at_top()) { | |||
event.stop(); | |||
return false; | |||
} else { | |||
|
r7339 | return true; | |
|
r5944 | }; | |
|
r7206 | } else if (event.which === key.ESC) { | |
|
r12459 | return IPython.tooltip.remove_and_cancel_tooltip(true); | |
|
r7199 | } else if (event.which === key.DOWNARROW && event.type === 'keydown') { | |
|
r5944 | // If we are not at the bottom, let CM handle the down arrow and | |
// prevent the global keydown handler from handling it. | |||
if (!that.at_bottom()) { | |||
event.stop(); | |||
return false; | |||
} else { | |||
|
r7339 | return true; | |
|
r5944 | }; | |
|
r8949 | } else if (event.keyCode === key.TAB && event.type == 'keydown' && event.shiftKey) { | |
if (editor.somethingSelected()){ | |||
var anchor = editor.getCursor("anchor"); | |||
var head = editor.getCursor("head"); | |||
if( anchor.line != head.line){ | |||
return false; | |||
} | |||
} | |||
IPython.tooltip.request(that); | |||
event.stop(); | |||
return true; | |||
|
r7193 | } else if (event.keyCode === key.TAB && event.type == 'keydown') { | |
|
r4555 | // Tab completion. | |
|
r5398 | //Do not trim here because of tooltip | |
|
r8587 | if (editor.somethingSelected()){return false} | |
|
r5398 | var pre_cursor = editor.getRange({line:cur.line,ch:0},cur); | |
if (pre_cursor.trim() === "") { | |||
|
r5016 | // Don't autocomplete if the part of the line before the cursor | |
// is empty. In this case, let CodeMirror handle indentation. | |||
|
r4393 | return false; | |
|
r8949 | } else if ((pre_cursor.substr(-1) === "("|| pre_cursor.substr(-1) === " ") && IPython.config.tooltip_on_tab ) { | |
|
r7160 | IPython.tooltip.request(that); | |
|
r6052 | // Prevent the event from bubbling up. | |
event.stop(); | |||
// Prevent CodeMirror from handling the tab. | |||
return true; | |||
|
r4393 | } else { | |
event.stop(); | |||
|
r7132 | this.completer.startCompletion(); | |
|
r4393 | return true; | |
|
r6059 | }; | |
} else { | |||
|
r5016 | // keypress/keyup also trigger on TAB press, and we don't want to | |
// use those to disable tab completion. | |||
|
r4378 | return false; | |
}; | |||
|
r5479 | return false; | |
|
r4378 | }; | |
|
r7197 | ||
|
r7168 | // Kernel related calls. | |
|
r12999 | CodeCell.prototype.set_session = function (session) { | |
this.session = session; | |||
|
r7197 | } | |
|
r8768 | /** | |
* Execute current code cell to the kernel | |||
* @method execute | |||
*/ | |||
|
r7168 | CodeCell.prototype.execute = function () { | |
|
r13102 | this.output_area.clear_output(); | |
|
r7168 | this.set_input_prompt('*'); | |
this.element.addClass("running"); | |||
var callbacks = { | |||
'execute_reply': $.proxy(this._handle_execute_reply, this), | |||
|
r7177 | 'output': $.proxy(this.output_area.handle_output, this.output_area), | |
'clear_output': $.proxy(this.output_area.handle_clear_output, this.output_area), | |||
|
r10368 | 'set_next_input': $.proxy(this._handle_set_next_input, this), | |
'input_request': $.proxy(this._handle_input_request, this) | |||
|
r7168 | }; | |
|
r13102 | this.last_msg_id = this.session.kernel.execute(this.get_text(), callbacks, {silent: false, store_history: true}); | |
|
r7168 | }; | |
|
r8768 | /** | |
* @method _handle_execute_reply | |||
* @private | |||
*/ | |||
|
r7168 | CodeCell.prototype._handle_execute_reply = function (content) { | |
this.set_input_prompt(content.execution_count); | |||
this.element.removeClass("running"); | |||
|
r10781 | $([IPython.events]).trigger('set_dirty.Notebook', {value: true}); | |
|
r7141 | } | |
|
r4389 | ||
|
r10368 | /** | |
* @method _handle_set_next_input | |||
* @private | |||
*/ | |||
|
r7223 | CodeCell.prototype._handle_set_next_input = function (text) { | |
var data = {'cell': this, 'text': text} | |||
$([IPython.events]).trigger('set_next_input.Notebook', data); | |||
} | |||
|
r12458 | ||
|
r10368 | /** | |
* @method _handle_input_request | |||
* @private | |||
*/ | |||
CodeCell.prototype._handle_input_request = function (content) { | |||
this.output_area.append_raw_input(content); | |||
} | |||
|
r7223 | ||
|
r7168 | // Basic cell manipulation. | |
|
r4352 | CodeCell.prototype.select = function () { | |
IPython.Cell.prototype.select.apply(this); | |||
|
r5942 | this.code_mirror.refresh(); | |
|
r4352 | this.code_mirror.focus(); | |
|
r8202 | this.auto_highlight(); | |
|
r5971 | // We used to need an additional refresh() after the focus, but | |
// it appears that this has been fixed in CM. This bug would show | |||
// up on FF when a newly loaded markdown cell was edited. | |||
|
r4352 | }; | |
|
r4675 | CodeCell.prototype.select_all = function () { | |
var start = {line: 0, ch: 0}; | |||
var nlines = this.code_mirror.lineCount(); | |||
var last_line = this.code_mirror.getLine(nlines-1); | |||
var end = {line: nlines-1, ch: last_line.length}; | |||
this.code_mirror.setSelection(start, end); | |||
}; | |||
|
r7168 | CodeCell.prototype.collapse = function () { | |
|
r7524 | this.collapsed = true; | |
this.output_area.collapse(); | |||
|
r7168 | }; | |
CodeCell.prototype.expand = function () { | |||
|
r7524 | this.collapsed = false; | |
this.output_area.expand(); | |||
|
r7168 | }; | |
CodeCell.prototype.toggle_output = function () { | |||
|
r7524 | this.collapsed = Boolean(1 - this.collapsed); | |
this.output_area.toggle_output(); | |||
|
r7168 | }; | |
|
r7429 | CodeCell.prototype.toggle_output_scroll = function () { | |
this.output_area.toggle_scroll(); | |||
}; | |||
|
r8467 | CodeCell.input_prompt_classical = function (prompt_value, lines_number) { | |
var ns = prompt_value || " "; | |||
return 'In [' + ns + ']:' | |||
}; | |||
|
r8768 | ||
|
r8467 | CodeCell.input_prompt_continuation = function (prompt_value, lines_number) { | |
var html = [CodeCell.input_prompt_classical(prompt_value, lines_number)]; | |||
for(var i=1; i < lines_number; i++){html.push(['...:'])}; | |||
return html.join('</br>') | |||
}; | |||
|
r8768 | ||
|
r8467 | CodeCell.input_prompt_function = CodeCell.input_prompt_classical; | |
|
r7168 | CodeCell.prototype.set_input_prompt = function (number) { | |
|
r8467 | var nline = 1 | |
if( this.code_mirror != undefined) { | |||
nline = this.code_mirror.lineCount(); | |||
} | |||
|
r8603 | this.input_prompt_number = number; | |
|
r8467 | var prompt_html = CodeCell.input_prompt_function(this.input_prompt_number, nline); | |
this.element.find('div.input_prompt').html(prompt_html); | |||
|
r7168 | }; | |
CodeCell.prototype.clear_input = function () { | |||
this.code_mirror.setValue(''); | |||
}; | |||
CodeCell.prototype.get_text = function () { | |||
return this.code_mirror.getValue(); | |||
}; | |||
CodeCell.prototype.set_text = function (code) { | |||
return this.code_mirror.setValue(code); | |||
}; | |||
CodeCell.prototype.at_top = function () { | |||
var cursor = this.code_mirror.getCursor(); | |||
|
r8168 | if (cursor.line === 0 && cursor.ch === 0) { | |
|
r7168 | return true; | |
} else { | |||
return false; | |||
} | |||
}; | |||
CodeCell.prototype.at_bottom = function () { | |||
var cursor = this.code_mirror.getCursor(); | |||
|
r8168 | if (cursor.line === (this.code_mirror.lineCount()-1) && cursor.ch === this.code_mirror.getLine(cursor.line).length) { | |
|
r7168 | return true; | |
} else { | |||
return false; | |||
} | |||
}; | |||
|
r13102 | CodeCell.prototype.clear_output = function (wait) { | |
this.output_area.clear_output(wait); | |||
|
r6423 | }; | |
|
r7168 | ||
// JSON serialization | |||
|
r4349 | ||
|
r4352 | CodeCell.prototype.fromJSON = function (data) { | |
|
r7523 | IPython.Cell.prototype.fromJSON.apply(this, arguments); | |
|
r4352 | if (data.cell_type === 'code') { | |
|
r4484 | if (data.input !== undefined) { | |
|
r5943 | this.set_text(data.input); | |
|
r7587 | // make this value the starting point, so that we can only undo | |
// to this state, instead of a blank cell | |||
this.code_mirror.clearHistory(); | |||
|
r8202 | this.auto_highlight(); | |
|
r4484 | } | |
if (data.prompt_number !== undefined) { | |||
this.set_input_prompt(data.prompt_number); | |||
} else { | |||
this.set_input_prompt(); | |||
}; | |||
|
r7177 | this.output_area.fromJSON(data.outputs); | |
|
r4533 | if (data.collapsed !== undefined) { | |
if (data.collapsed) { | |||
this.collapse(); | |||
|
r6032 | } else { | |
this.expand(); | |||
|
r4533 | }; | |
}; | |||
|
r4352 | }; | |
}; | |||
CodeCell.prototype.toJSON = function () { | |||
|
r7523 | var data = IPython.Cell.prototype.toJSON.apply(this); | |
|
r5943 | data.input = this.get_text(); | |
|
r4484 | data.cell_type = 'code'; | |
|
r5814 | if (this.input_prompt_number) { | |
|
r5479 | data.prompt_number = this.input_prompt_number; | |
|
r4352 | }; | |
|
r7177 | var outputs = this.output_area.toJSON(); | |
|
r4497 | data.outputs = outputs; | |
|
r4484 | data.language = 'python'; | |
|
r4533 | data.collapsed = this.collapsed; | |
|
r4484 | return data; | |
|
r4352 | }; | |
|
r4497 | ||
|
r4352 | IPython.CodeCell = CodeCell; | |
return IPython; | |||
|
r13060 | }(IPython)); |