codemirror.js
3229 lines
| 129.9 KiB
| application/javascript
|
JavascriptLexer
|
r4504 | // All functions that need access to the editor's state live inside | ||
// the CodeMirror function. Below that, at the bottom of the file, | ||||
// some utilities are defined. | ||||
// CodeMirror is the only global var we claim | ||||
var CodeMirror = (function() { | ||||
|
r8053 | // This is the function that produces an editor instance. Its | ||
|
r4504 | // closure is used to store the editor state. | ||
function CodeMirror(place, givenOptions) { | ||||
// Determine effective options based on given values and defaults. | ||||
var options = {}, defaults = CodeMirror.defaults; | ||||
for (var opt in defaults) | ||||
if (defaults.hasOwnProperty(opt)) | ||||
options[opt] = (givenOptions && givenOptions.hasOwnProperty(opt) ? givenOptions : defaults)[opt]; | ||||
// The element in which the editor lives. | ||||
|
r8053 | var wrapper = document.createElement("div"); | ||
|
r5941 | wrapper.className = "CodeMirror" + (options.lineWrapping ? " CodeMirror-wrap" : ""); | ||
|
r4504 | // This mess creates the base DOM structure for the editor. | ||
wrapper.innerHTML = | ||||
|
r5941 | '<div style="overflow: hidden; position: relative; width: 3px; height: 0px;">' + // Wraps and hides input textarea | ||
|
r5970 | '<textarea style="position: absolute; padding: 0; width: 1px; height: 1em" wrap="off" ' + | ||
|
r4933 | 'autocorrect="off" autocapitalize="off"></textarea></div>' + | ||
|
r8053 | '<div class="CodeMirror-scrollbar">' + // The vertical scrollbar. Horizontal scrolling is handled by the scroller itself. | ||
'<div class="CodeMirror-scrollbar-inner">' + // The empty scrollbar content, used solely for managing the scrollbar thumb. | ||||
'</div></div>' + // This must be before the scroll area because it's float-right. | ||||
|
r5941 | '<div class="CodeMirror-scroll" tabindex="-1">' + | ||
|
r4504 | '<div style="position: relative">' + // Set to the height of the text, causes scrolling | ||
'<div style="position: relative">' + // Moved around its parent to cover visible view | ||||
'<div class="CodeMirror-gutter"><div class="CodeMirror-gutter-text"></div></div>' + | ||||
// Provides positioning relative to (visible) text origin | ||||
|
r5970 | '<div class="CodeMirror-lines"><div style="position: relative; z-index: 0">' + | ||
|
r8053 | // Used to measure text size | ||
'<div style="position: absolute; width: 100%; height: 0px; overflow: hidden; visibility: hidden;"></div>' + | ||||
|
r4504 | '<pre class="CodeMirror-cursor"> </pre>' + // Absolutely positioned blinky cursor | ||
|
r8053 | '<pre class="CodeMirror-cursor" style="visibility: hidden"> </pre>' + // Used to force a width | ||
|
r5970 | '<div style="position: relative; z-index: -1"></div><div></div>' + // DIVs containing the selection and the actual code | ||
|
r4504 | '</div></div></div></div></div>'; | ||
if (place.appendChild) place.appendChild(wrapper); else place(wrapper); | ||||
// I've never seen more elegant code in my life. | ||||
var inputDiv = wrapper.firstChild, input = inputDiv.firstChild, | ||||
scroller = wrapper.lastChild, code = scroller.firstChild, | ||||
|
r5941 | mover = code.firstChild, gutter = mover.firstChild, gutterText = gutter.firstChild, | ||
lineSpace = gutter.nextSibling.firstChild, measure = lineSpace.firstChild, | ||||
|
r8053 | cursor = measure.nextSibling, widthForcer = cursor.nextSibling, | ||
selectionDiv = widthForcer.nextSibling, lineDiv = selectionDiv.nextSibling, | ||||
scrollbar = inputDiv.nextSibling, scrollbarInner = scrollbar.firstChild; | ||||
themeChanged(); keyMapChanged(); | ||||
|
r5941 | // Needed to hide big blue blinking cursor on Mobile Safari | ||
|
r5970 | if (ios) input.style.width = "0px"; | ||
|
r8053 | if (!webkit) scroller.draggable = true; | ||
|
r5970 | lineSpace.style.outline = "none"; | ||
|
r5941 | if (options.tabindex != null) input.tabIndex = options.tabindex; | ||
|
r8053 | if (options.autofocus) focusInput(); | ||
|
r4504 | if (!options.gutter && !options.lineNumbers) gutter.style.display = "none"; | ||
|
r8053 | // Needed to handle Tab key in KHTML | ||
if (khtml) inputDiv.style.height = "1px", inputDiv.style.position = "absolute"; | ||||
// Check for OS X >= 10.7. If so, we need to force a width on the scrollbar, and | ||||
// make it overlap the content. (But we only do this if the scrollbar doesn't already | ||||
// have a natural width. If the mouse is plugged in or the user sets the system pref | ||||
// to always show scrollbars, the scrollbar shouldn't overlap.) | ||||
if (mac_geLion) { | ||||
scrollbar.className += (overlapScrollbars() ? " cm-sb-overlap" : " cm-sb-nonoverlap"); | ||||
} else if (ie_lt8) { | ||||
// Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8). | ||||
scrollbar.className += " cm-sb-ie7"; | ||||
} | ||||
|
r4504 | |||
|
r5941 | // Check for problem with IE innerHTML not working when we have a | ||
// P (or similar) parent node. | ||||
try { stringWidth("x"); } | ||||
catch (e) { | ||||
if (e.message.match(/runtime/i)) | ||||
e = new Error("A CodeMirror inside a P-style element does not work in Internet Explorer. (innerHTML bug)"); | ||||
throw e; | ||||
} | ||||
|
r4504 | // Delayed object wrap timeouts, making sure only one is active. blinker holds an interval. | ||
var poll = new Delayed(), highlight = new Delayed(), blinker; | ||||
|
r5941 | // mode holds a mode API object. doc is the tree of Line objects, | ||
// work an array of lines that should be parsed, and history the | ||||
// undo history (instance of History constructor). | ||||
var mode, doc = new BranchChunk([new LeafChunk([new Line("")])]), work, focused; | ||||
|
r4504 | loadMode(); | ||
// The selection. These are always maintained to point at valid | ||||
// positions. Inverted is used to remember that the user is | ||||
// selecting bottom-to-top. | ||||
var sel = {from: {line: 0, ch: 0}, to: {line: 0, ch: 0}, inverted: false}; | ||||
// Selection-related flags. shiftSelecting obviously tracks | ||||
|
r5941 | // whether the user is holding shift. | ||
|
r8053 | var shiftSelecting, lastClick, lastDoubleClick, lastScrollTop = 0, lastScrollLeft = 0, draggingText, | ||
|
r5970 | overwrite = false, suppressEdits = false; | ||
|
r4504 | // Variables used by startOperation/endOperation to track what | ||
// happened during the operation. | ||||
|
r5941 | var updateInput, userSelChange, changes, textChanged, selectionChanged, leaveInputAlone, | ||
gutterDirty, callbacks; | ||||
|
r4504 | // Current visible range (may be bigger than the view window). | ||
|
r5941 | var displayOffset = 0, showingFrom = 0, showingTo = 0, lastSizeC = 0; | ||
|
r8053 | // bracketHighlighted is used to remember that a bracket has been | ||
|
r4504 | // marked. | ||
|
r5941 | var bracketHighlighted; | ||
|
r4504 | // Tracks the maximum line length so that the horizontal scrollbar | ||
// can be kept static when scrolling. | ||||
|
r8053 | var maxLine = "", updateMaxLine = false, maxLineChanged = true; | ||
var tabCache = {}; | ||||
|
r4504 | |||
// Initialize the content. | ||||
operation(function(){setValue(options.value || ""); updateInput = false;})(); | ||||
|
r5941 | var history = new History(); | ||
|
r4504 | |||
// Register our event handlers. | ||||
connect(scroller, "mousedown", operation(onMouseDown)); | ||||
|
r5941 | connect(scroller, "dblclick", operation(onDoubleClick)); | ||
connect(lineSpace, "selectstart", e_preventDefault); | ||||
|
r4504 | // Gecko browsers fire contextmenu *after* opening the menu, at | ||
// which point we can't mess with it anymore. Context menu is | ||||
// handled in onMouseDown for Gecko. | ||||
if (!gecko) connect(scroller, "contextmenu", onContextMenu); | ||||
|
r8053 | connect(scroller, "scroll", onScroll); | ||
connect(scrollbar, "scroll", onScroll); | ||||
connect(scrollbar, "mousedown", function() {if (focused) setTimeout(focusInput, 0);}); | ||||
connect(scroller, "mousewheel", onMouseWheel); | ||||
connect(scroller, "DOMMouseScroll", onMouseWheel); | ||||
|
r4504 | connect(window, "resize", function() {updateDisplay(true);}); | ||
connect(input, "keyup", operation(onKeyUp)); | ||||
|
r5941 | connect(input, "input", fastPoll); | ||
|
r4504 | connect(input, "keydown", operation(onKeyDown)); | ||
connect(input, "keypress", operation(onKeyPress)); | ||||
connect(input, "focus", onFocus); | ||||
connect(input, "blur", onBlur); | ||||
|
r8053 | if (options.dragDrop) { | ||
connect(scroller, "dragstart", onDragStart); | ||||
function drag_(e) { | ||||
if (options.onDragEvent && options.onDragEvent(instance, addStop(e))) return; | ||||
e_stop(e); | ||||
} | ||||
connect(scroller, "dragenter", drag_); | ||||
connect(scroller, "dragover", drag_); | ||||
connect(scroller, "drop", operation(onDrop)); | ||||
} | ||||
|
r4504 | connect(scroller, "paste", function(){focusInput(); fastPoll();}); | ||
|
r5941 | connect(input, "paste", fastPoll); | ||
|
r5970 | connect(input, "cut", operation(function(){ | ||
if (!options.readOnly) replaceSelection(""); | ||||
})); | ||||
|
r4934 | |||
|
r8053 | // Needed to handle Tab key in KHTML | ||
if (khtml) connect(code, "mouseup", function() { | ||||
if (document.activeElement == input) input.blur(); | ||||
focusInput(); | ||||
}); | ||||
|
r4934 | // IE throws unspecified error in certain cases, when | ||
|
r4504 | // trying to access activeElement before onload | ||
|
r8053 | var hasFocus; try { hasFocus = (document.activeElement == input); } catch(e) { } | ||
if (hasFocus || options.autofocus) setTimeout(onFocus, 20); | ||||
|
r4504 | else onBlur(); | ||
|
r5941 | function isLine(l) {return l >= 0 && l < doc.size;} | ||
|
r4504 | // The instance object that we'll return. Mostly calls out to | ||
// local functions in the CodeMirror function. Some do some extra | ||||
// range checking and/or clipping. operation is used to wrap the | ||||
// call so that changes it makes are tracked, and the display is | ||||
// updated afterwards. | ||||
|
r4933 | var instance = wrapper.CodeMirror = { | ||
|
r4504 | getValue: getValue, | ||
setValue: operation(setValue), | ||||
getSelection: getSelection, | ||||
replaceSelection: operation(replaceSelection), | ||||
|
r8053 | focus: function(){window.focus(); focusInput(); onFocus(); fastPoll();}, | ||
|
r4504 | setOption: function(option, value) { | ||
|
r5941 | var oldVal = options[option]; | ||
|
r4504 | options[option] = value; | ||
|
r5941 | if (option == "mode" || option == "indentUnit") loadMode(); | ||
|
r5970 | else if (option == "readOnly" && value == "nocursor") {onBlur(); input.blur();} | ||
else if (option == "readOnly" && !value) {resetInput(true);} | ||||
|
r5941 | else if (option == "theme") themeChanged(); | ||
else if (option == "lineWrapping" && oldVal != value) operation(wrappingChanged)(); | ||||
|
r8053 | else if (option == "tabSize") updateDisplay(true); | ||
else if (option == "keyMap") keyMapChanged(); | ||||
|
r6058 | if (option == "lineNumbers" || option == "gutter" || option == "firstLineNumber" || option == "theme") { | ||
gutterChanged(); | ||||
|
r5970 | updateDisplay(true); | ||
|
r6058 | } | ||
|
r4504 | }, | ||
getOption: function(option) {return options[option];}, | ||||
undo: operation(undo), | ||||
redo: operation(redo), | ||||
|
r4933 | indentLine: operation(function(n, dir) { | ||
|
r5970 | if (typeof dir != "string") { | ||
if (dir == null) dir = options.smartIndent ? "smart" : "prev"; | ||||
else dir = dir ? "add" : "subtract"; | ||||
} | ||||
if (isLine(n)) indentLine(n, dir); | ||||
|
r4933 | }), | ||
|
r5941 | indentSelection: operation(indentSelected), | ||
|
r4504 | historySize: function() {return {undo: history.done.length, redo: history.undone.length};}, | ||
|
r5941 | clearHistory: function() {history = new History();}, | ||
|
r8053 | setHistory: function(histData) { | ||
history = new History(); | ||||
history.done = histData.done; | ||||
history.undone = histData.undone; | ||||
}, | ||||
getHistory: function() { | ||||
history.time = 0; | ||||
return {done: history.done.concat([]), undone: history.undone.concat([])}; | ||||
}, | ||||
|
r4504 | matchBrackets: operation(function(){matchBrackets(true);}), | ||
|
r5941 | getTokenAt: operation(function(pos) { | ||
|
r4504 | pos = clipPos(pos); | ||
|
r5941 | return getLine(pos.line).getTokenAt(mode, getStateBefore(pos.line), pos.ch); | ||
}), | ||||
|
r4504 | getStateAfter: function(line) { | ||
|
r5941 | line = clipLine(line == null ? doc.size - 1: line); | ||
|
r4504 | return getStateBefore(line + 1); | ||
}, | ||||
|
r8053 | cursorCoords: function(start, mode) { | ||
|
r4504 | if (start == null) start = sel.inverted; | ||
|
r8053 | return this.charCoords(start ? sel.from : sel.to, mode); | ||
}, | ||||
charCoords: function(pos, mode) { | ||||
pos = clipPos(pos); | ||||
if (mode == "local") return localCoords(pos, false); | ||||
if (mode == "div") return localCoords(pos, true); | ||||
return pageCoords(pos); | ||||
|
r4504 | }, | ||
coordsChar: function(coords) { | ||||
var off = eltOffset(lineSpace); | ||||
|
r5941 | return coordsChar(coords.x - off.left, coords.y - off.top); | ||
|
r4504 | }, | ||
|
r5941 | markText: operation(markText), | ||
setBookmark: setBookmark, | ||||
|
r8053 | findMarksAt: findMarksAt, | ||
|
r4933 | setMarker: operation(addGutterMarker), | ||
clearMarker: operation(removeGutterMarker), | ||||
|
r4504 | setLineClass: operation(setLineClass), | ||
|
r5941 | hideLine: operation(function(h) {return setLineHidden(h, true);}), | ||
showLine: operation(function(h) {return setLineHidden(h, false);}), | ||||
onDeleteLine: function(line, f) { | ||||
if (typeof line == "number") { | ||||
if (!isLine(line)) return null; | ||||
line = getLine(line); | ||||
} | ||||
(line.handlers || (line.handlers = [])).push(f); | ||||
return line; | ||||
}, | ||||
|
r4504 | lineInfo: lineInfo, | ||
|
r4933 | addWidget: function(pos, node, scroll, vert, horiz) { | ||
|
r4504 | pos = localCoords(clipPos(pos)); | ||
var top = pos.yBot, left = pos.x; | ||||
node.style.position = "absolute"; | ||||
code.appendChild(node); | ||||
|
r4933 | if (vert == "over") top = pos.y; | ||
else if (vert == "near") { | ||||
|
r5941 | var vspace = Math.max(scroller.offsetHeight, doc.height * textHeight()), | ||
|
r4504 | hspace = Math.max(code.clientWidth, lineSpace.clientWidth) - paddingLeft(); | ||
if (pos.yBot + node.offsetHeight > vspace && pos.y > node.offsetHeight) | ||||
top = pos.y - node.offsetHeight; | ||||
if (left + node.offsetWidth > hspace) | ||||
left = hspace - node.offsetWidth; | ||||
} | ||||
node.style.top = (top + paddingTop()) + "px"; | ||||
|
r4933 | node.style.left = node.style.right = ""; | ||
if (horiz == "right") { | ||||
left = code.clientWidth - node.offsetWidth; | ||||
node.style.right = "0px"; | ||||
} else { | ||||
if (horiz == "left") left = 0; | ||||
else if (horiz == "middle") left = (code.clientWidth - node.offsetWidth) / 2; | ||||
node.style.left = (left + paddingLeft()) + "px"; | ||||
} | ||||
|
r4504 | if (scroll) | ||
scrollIntoView(left, top, left + node.offsetWidth, top + node.offsetHeight); | ||||
}, | ||||
|
r5941 | lineCount: function() {return doc.size;}, | ||
clipPos: clipPos, | ||||
|
r4504 | getCursor: function(start) { | ||
if (start == null) start = sel.inverted; | ||||
return copyPos(start ? sel.from : sel.to); | ||||
}, | ||||
somethingSelected: function() {return !posEq(sel.from, sel.to);}, | ||||
|
r5941 | setCursor: operation(function(line, ch, user) { | ||
if (ch == null && typeof line.line == "number") setCursor(line.line, line.ch, user); | ||||
else setCursor(line, ch, user); | ||||
|
r4504 | }), | ||
|
r5941 | setSelection: operation(function(from, to, user) { | ||
(user ? setSelectionUser : setSelection)(clipPos(from), clipPos(to || from)); | ||||
}), | ||||
getLine: function(line) {if (isLine(line)) return getLine(line).text;}, | ||||
getLineHandle: function(line) {if (isLine(line)) return getLine(line);}, | ||||
|
r4504 | setLine: operation(function(line, text) { | ||
|
r5941 | if (isLine(line)) replaceRange(text, {line: line, ch: 0}, {line: line, ch: getLine(line).text.length}); | ||
|
r4504 | }), | ||
removeLine: operation(function(line) { | ||||
if (isLine(line)) replaceRange("", {line: line, ch: 0}, clipPos({line: line+1, ch: 0})); | ||||
}), | ||||
replaceRange: operation(replaceRange), | ||||
|
r8053 | getRange: function(from, to, lineSep) {return getRange(clipPos(from), clipPos(to), lineSep);}, | ||
|
r4504 | |||
|
r8053 | triggerOnKeyDown: operation(onKeyDown), | ||
|
r5941 | execCommand: function(cmd) {return commands[cmd](instance);}, | ||
// Stuff used by commands, probably not much use to outside code. | ||||
moveH: operation(moveH), | ||||
deleteH: operation(deleteH), | ||||
moveV: operation(moveV), | ||||
|
r8053 | toggleOverwrite: function() { | ||
if(overwrite){ | ||||
overwrite = false; | ||||
cursor.className = cursor.className.replace(" CodeMirror-overwrite", ""); | ||||
} else { | ||||
overwrite = true; | ||||
cursor.className += " CodeMirror-overwrite"; | ||||
} | ||||
}, | ||||
|
r5941 | |||
posFromIndex: function(off) { | ||||
var lineNo = 0, ch; | ||||
doc.iter(0, doc.size, function(line) { | ||||
var sz = line.text.length + 1; | ||||
if (sz > off) { ch = off; return true; } | ||||
off -= sz; | ||||
++lineNo; | ||||
}); | ||||
return clipPos({line: lineNo, ch: ch}); | ||||
}, | ||||
indexFromPos: function (coords) { | ||||
if (coords.line < 0 || coords.ch < 0) return 0; | ||||
var index = coords.ch; | ||||
doc.iter(0, coords.line, function (line) { | ||||
index += line.text.length + 1; | ||||
}); | ||||
return index; | ||||
}, | ||||
|
r5970 | scrollTo: function(x, y) { | ||
|
r6058 | if (x != null) scroller.scrollLeft = x; | ||
|
r8053 | if (y != null) scrollbar.scrollTop = y; | ||
|
r5970 | updateDisplay([]); | ||
}, | ||||
|
r8053 | getScrollInfo: function() { | ||
return {x: scroller.scrollLeft, y: scrollbar.scrollTop, | ||||
height: scrollbar.scrollHeight, width: scroller.scrollWidth}; | ||||
}, | ||||
setSize: function(width, height) { | ||||
function interpret(val) { | ||||
val = String(val); | ||||
return /^\d+$/.test(val) ? val + "px" : val; | ||||
} | ||||
if (width != null) wrapper.style.width = interpret(width); | ||||
if (height != null) scroller.style.height = interpret(height); | ||||
}, | ||||
|
r5941 | |||
|
r4504 | operation: function(f){return operation(f)();}, | ||
|
r8053 | compoundChange: function(f){return compoundChange(f);}, | ||
|
r5970 | refresh: function(){ | ||
|
r8053 | updateDisplay(true, null, lastScrollTop); | ||
if (scrollbar.scrollHeight > lastScrollTop) | ||||
scrollbar.scrollTop = lastScrollTop; | ||||
|
r5970 | }, | ||
|
r4504 | getInputField: function(){return input;}, | ||
getWrapperElement: function(){return wrapper;}, | ||||
|
r4933 | getScrollerElement: function(){return scroller;}, | ||
getGutterElement: function(){return gutter;} | ||||
|
r4504 | }; | ||
|
r5941 | function getLine(n) { return getLineAt(doc, n); } | ||
function updateLineHeight(line, height) { | ||||
gutterDirty = true; | ||||
var diff = height - line.height; | ||||
for (var n = line; n; n = n.parent) n.height += diff; | ||||
} | ||||
|
r4504 | function setValue(code) { | ||
var top = {line: 0, ch: 0}; | ||||
|
r5941 | updateLines(top, {line: doc.size - 1, ch: getLine(doc.size-1).text.length}, | ||
|
r4504 | splitLines(code), top, top); | ||
|
r4933 | updateInput = true; | ||
|
r4504 | } | ||
|
r8053 | function getValue(lineSep) { | ||
|
r4504 | var text = []; | ||
|
r5941 | doc.iter(0, doc.size, function(line) { text.push(line.text); }); | ||
|
r8053 | return text.join(lineSep || "\n"); | ||
} | ||||
function onScroll(e) { | ||||
if (scroller.scrollTop) { | ||||
scrollbar.scrollTop += scroller.scrollTop; | ||||
scroller.scrollTop = 0; | ||||
} | ||||
if (lastScrollTop != scrollbar.scrollTop || lastScrollLeft != scroller.scrollLeft) { | ||||
lastScrollTop = scrollbar.scrollTop; | ||||
lastScrollLeft = scroller.scrollLeft; | ||||
updateDisplay([]); | ||||
if (options.fixedGutter) gutter.style.left = scroller.scrollLeft + "px"; | ||||
if (options.onScroll) options.onScroll(instance); | ||||
} | ||||
|
r4504 | } | ||
function onMouseDown(e) { | ||||
|
r5970 | setShift(e_prop(e, "shiftKey")); | ||
|
r4504 | // Check whether this is a click in a widget | ||
for (var n = e_target(e); n != wrapper; n = n.parentNode) | ||||
if (n.parentNode == code && n != mover) return; | ||||
|
r4933 | |||
|
r5941 | // See if this is a click in the gutter | ||
|
r4504 | for (var n = e_target(e); n != wrapper; n = n.parentNode) | ||
if (n.parentNode == gutterText) { | ||||
if (options.onGutterClick) | ||||
|
r4933 | options.onGutterClick(instance, indexOf(gutterText.childNodes, n) + showingFrom, e); | ||
|
r4504 | return e_preventDefault(e); | ||
} | ||||
var start = posFromMouse(e); | ||||
|
r4934 | |||
|
r4504 | switch (e_button(e)) { | ||
case 3: | ||||
|
r8053 | if (gecko) onContextMenu(e); | ||
|
r4504 | return; | ||
case 2: | ||||
if (start) setCursor(start.line, start.ch, true); | ||||
|
r8053 | setTimeout(focusInput, 20); | ||
e_preventDefault(e); | ||||
|
r4504 | return; | ||
} | ||||
// For button 1, if it was clicked inside the editor | ||||
// (posFromMouse returning non-null), we have to adjust the | ||||
// selection. | ||||
if (!start) {if (e_target(e) == scroller) e_preventDefault(e); return;} | ||||
if (!focused) onFocus(); | ||||
|
r8053 | var now = +new Date, type = "single"; | ||
|
r5941 | if (lastDoubleClick && lastDoubleClick.time > now - 400 && posEq(lastDoubleClick.pos, start)) { | ||
|
r8053 | type = "triple"; | ||
|
r4933 | e_preventDefault(e); | ||
|
r5941 | setTimeout(focusInput, 20); | ||
|
r8053 | selectLine(start.line); | ||
|
r5941 | } else if (lastClick && lastClick.time > now - 400 && posEq(lastClick.pos, start)) { | ||
|
r8053 | type = "double"; | ||
|
r5941 | lastDoubleClick = {time: now, pos: start}; | ||
|
r4933 | e_preventDefault(e); | ||
|
r8053 | var word = findWordAt(start); | ||
setSelectionUser(word.from, word.to); | ||||
|
r5941 | } else { lastClick = {time: now, pos: start}; } | ||
|
r4933 | |||
|
r4504 | var last = start, going; | ||
|
r8053 | if (options.dragDrop && dragAndDrop && !options.readOnly && !posEq(sel.from, sel.to) && | ||
!posLess(start, sel.from) && !posLess(sel.to, start) && type == "single") { | ||||
|
r4933 | // Let the drag handler handle this. | ||
|
r8053 | if (webkit) scroller.draggable = true; | ||
function dragEnd(e2) { | ||||
if (webkit) scroller.draggable = false; | ||||
|
r5941 | draggingText = false; | ||
|
r8053 | up(); drop(); | ||
|
r5941 | if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) { | ||
e_preventDefault(e2); | ||||
setCursor(start.line, start.ch, true); | ||||
focusInput(); | ||||
} | ||||
|
r8053 | } | ||
var up = connect(document, "mouseup", operation(dragEnd), true); | ||||
var drop = connect(scroller, "drop", operation(dragEnd), true); | ||||
|
r5941 | draggingText = true; | ||
|
r8053 | // IE's approach to draggable | ||
if (scroller.dragDrop) scroller.dragDrop(); | ||||
|
r4933 | return; | ||
|
r4504 | } | ||
|
r4933 | e_preventDefault(e); | ||
|
r8053 | if (type == "single") setCursor(start.line, start.ch, true); | ||
var startstart = sel.from, startend = sel.to; | ||||
function doSelect(cur) { | ||||
if (type == "single") { | ||||
setSelectionUser(start, cur); | ||||
} else if (type == "double") { | ||||
var word = findWordAt(cur); | ||||
if (posLess(cur, startstart)) setSelectionUser(word.from, startend); | ||||
else setSelectionUser(startstart, word.to); | ||||
} else if (type == "triple") { | ||||
if (posLess(cur, startstart)) setSelectionUser(startend, clipPos({line: cur.line, ch: 0})); | ||||
else setSelectionUser(startstart, clipPos({line: cur.line + 1, ch: 0})); | ||||
} | ||||
} | ||||
|
r4933 | |||
|
r4504 | function extend(e) { | ||
var cur = posFromMouse(e, true); | ||||
if (cur && !posEq(cur, last)) { | ||||
if (!focused) onFocus(); | ||||
last = cur; | ||||
|
r8053 | doSelect(cur); | ||
|
r4504 | updateInput = false; | ||
var visible = visibleLines(); | ||||
if (cur.line >= visible.to || cur.line < visible.from) | ||||
going = setTimeout(operation(function(){extend(e);}), 150); | ||||
} | ||||
} | ||||
|
r8053 | function done(e) { | ||
|
r4504 | clearTimeout(going); | ||
var cur = posFromMouse(e); | ||||
|
r8053 | if (cur) doSelect(cur); | ||
|
r4504 | e_preventDefault(e); | ||
|
r4933 | focusInput(); | ||
updateInput = true; | ||||
move(); up(); | ||||
|
r8053 | } | ||
var move = connect(document, "mousemove", operation(function(e) { | ||||
clearTimeout(going); | ||||
e_preventDefault(e); | ||||
if (!ie && !e_button(e)) done(e); | ||||
else extend(e); | ||||
|
r4504 | }), true); | ||
|
r8053 | var up = connect(document, "mouseup", operation(done), true); | ||
|
r4504 | } | ||
|
r5941 | function onDoubleClick(e) { | ||
for (var n = e_target(e); n != wrapper; n = n.parentNode) | ||||
if (n.parentNode == gutterText) return e_preventDefault(e); | ||||
e_preventDefault(e); | ||||
} | ||||
|
r4504 | function onDrop(e) { | ||
|
r8053 | if (options.onDragEvent && options.onDragEvent(instance, addStop(e))) return; | ||
|
r4504 | e.preventDefault(); | ||
var pos = posFromMouse(e, true), files = e.dataTransfer.files; | ||||
if (!pos || options.readOnly) return; | ||||
if (files && files.length && window.FileReader && window.File) { | ||||
function loadFile(file, i) { | ||||
var reader = new FileReader; | ||||
reader.onload = function() { | ||||
text[i] = reader.result; | ||||
|
r5941 | if (++read == n) { | ||
|
r8053 | pos = clipPos(pos); | ||
operation(function() { | ||||
|
r5941 | var end = replaceRange(text.join(""), pos, pos); | ||
setSelectionUser(pos, end); | ||||
})(); | ||||
|
r8053 | } | ||
|
r4504 | }; | ||
reader.readAsText(file); | ||||
} | ||||
var n = files.length, text = Array(n), read = 0; | ||||
for (var i = 0; i < n; ++i) loadFile(files[i], i); | ||||
|
r8053 | } else { | ||
// Don't do a replace if the drop happened inside of the selected text. | ||||
if (draggingText && !(posLess(pos, sel.from) || posLess(sel.to, pos))) return; | ||||
|
r4504 | try { | ||
var text = e.dataTransfer.getData("Text"); | ||||
|
r5941 | if (text) { | ||
|
r8053 | compoundChange(function() { | ||
var curFrom = sel.from, curTo = sel.to; | ||||
setSelectionUser(pos, pos); | ||||
if (draggingText) replaceRange("", curFrom, curTo); | ||||
replaceSelection(text); | ||||
focusInput(); | ||||
}); | ||||
} | ||||
|
r4504 | } | ||
catch(e){} | ||||
} | ||||
} | ||||
|
r4933 | function onDragStart(e) { | ||
var txt = getSelection(); | ||||
e.dataTransfer.setData("Text", txt); | ||||
|
r8053 | |||
// Use dummy image instead of default browsers image. | ||||
if (gecko || chrome || opera) { | ||||
var img = document.createElement('img'); | ||||
img.scr = 'data:image/gif;base64,R0lGODdhAgACAIAAAAAAAP///ywAAAAAAgACAAACAoRRADs='; //1x1 image | ||||
e.dataTransfer.setDragImage(img, 0, 0); | ||||
|
r5941 | } | ||
|
r8053 | } | ||
function doHandleBinding(bound, dropShift) { | ||||
|
r5941 | if (typeof bound == "string") { | ||
|
r8053 | bound = commands[bound]; | ||
if (!bound) return false; | ||||
|
r5941 | } | ||
|
r5970 | var prevShift = shiftSelecting; | ||
try { | ||||
if (options.readOnly) suppressEdits = true; | ||||
if (dropShift) shiftSelecting = null; | ||||
|
r5941 | bound(instance); | ||
|
r8053 | } catch(e) { | ||
if (e != Pass) throw e; | ||||
return false; | ||||
|
r5970 | } finally { | ||
|
r5941 | shiftSelecting = prevShift; | ||
|
r5970 | suppressEdits = false; | ||
} | ||||
|
r5941 | return true; | ||
} | ||||
|
r8053 | function handleKeyBinding(e) { | ||
// Handle auto keymap transitions | ||||
var startMap = getKeyMap(options.keyMap), next = startMap.auto; | ||||
clearTimeout(maybeTransition); | ||||
if (next && !isModifierKey(e)) maybeTransition = setTimeout(function() { | ||||
if (getKeyMap(options.keyMap) == startMap) { | ||||
options.keyMap = (next.call ? next.call(null, instance) : next); | ||||
} | ||||
}, 50); | ||||
var name = keyNames[e_prop(e, "keyCode")], handled = false; | ||||
if (name == null || e.altGraphKey) return false; | ||||
if (e_prop(e, "altKey")) name = "Alt-" + name; | ||||
if (e_prop(e, "ctrlKey")) name = "Ctrl-" + name; | ||||
if (e_prop(e, "metaKey")) name = "Cmd-" + name; | ||||
var stopped = false; | ||||
function stop() { stopped = true; } | ||||
if (e_prop(e, "shiftKey")) { | ||||
handled = lookupKey("Shift-" + name, options.extraKeys, options.keyMap, | ||||
function(b) {return doHandleBinding(b, true);}, stop) | ||||
|| lookupKey(name, options.extraKeys, options.keyMap, function(b) { | ||||
if (typeof b == "string" && /^go[A-Z]/.test(b)) return doHandleBinding(b); | ||||
}, stop); | ||||
} else { | ||||
handled = lookupKey(name, options.extraKeys, options.keyMap, doHandleBinding, stop); | ||||
} | ||||
if (stopped) handled = false; | ||||
if (handled) { | ||||
e_preventDefault(e); | ||||
restartBlink(); | ||||
if (ie) { e.oldKeyCode = e.keyCode; e.keyCode = 0; } | ||||
} | ||||
return handled; | ||||
} | ||||
function handleCharBinding(e, ch) { | ||||
var handled = lookupKey("'" + ch + "'", options.extraKeys, | ||||
options.keyMap, function(b) { return doHandleBinding(b, true); }); | ||||
if (handled) { | ||||
e_preventDefault(e); | ||||
restartBlink(); | ||||
} | ||||
return handled; | ||||
} | ||||
var lastStoppedKey = null, maybeTransition; | ||||
|
r4504 | function onKeyDown(e) { | ||
if (!focused) onFocus(); | ||||
|
r5970 | if (ie && e.keyCode == 27) { e.returnValue = false; } | ||
|
r8053 | if (pollingFast) { if (readInput()) pollingFast = false; } | ||
|
r5970 | if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return; | ||
var code = e_prop(e, "keyCode"); | ||||
|
r4504 | // IE does strange things with escape. | ||
|
r5970 | setShift(code == 16 || e_prop(e, "shiftKey")); | ||
|
r4504 | // First give onKeyEvent option a chance to handle this. | ||
|
r5941 | var handled = handleKeyBinding(e); | ||
|
r8053 | if (opera) { | ||
|
r5970 | lastStoppedKey = handled ? code : null; | ||
|
r5941 | // Opera has no cut event... we try to at least catch the key combo | ||
|
r5970 | if (!handled && code == 88 && e_prop(e, mac ? "metaKey" : "ctrlKey")) | ||
|
r5941 | replaceSelection(""); | ||
|
r4504 | } | ||
} | ||||
function onKeyPress(e) { | ||||
|
r8053 | if (pollingFast) readInput(); | ||
|
r6058 | if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return; | ||
|
r5970 | var keyCode = e_prop(e, "keyCode"), charCode = e_prop(e, "charCode"); | ||
|
r8053 | if (opera && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;} | ||
if (((opera && (!e.which || e.which < 10)) || khtml) && handleKeyBinding(e)) return; | ||||
var ch = String.fromCharCode(charCode == null ? keyCode : charCode); | ||||
|
r5970 | if (options.electricChars && mode.electricChars && options.smartIndent && !options.readOnly) { | ||
|
r4504 | if (mode.electricChars.indexOf(ch) > -1) | ||
|
r5941 | setTimeout(operation(function() {indentLine(sel.to.line, "smart");}), 75); | ||
|
r4504 | } | ||
|
r8053 | if (handleCharBinding(e, ch)) return; | ||
|
r5941 | fastPoll(); | ||
} | ||||
function onKeyUp(e) { | ||||
if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return; | ||||
|
r5970 | if (e_prop(e, "keyCode") == 16) shiftSelecting = null; | ||
|
r4504 | } | ||
function onFocus() { | ||||
|
r5970 | if (options.readOnly == "nocursor") return; | ||
|
r4504 | if (!focused) { | ||
if (options.onFocus) options.onFocus(instance); | ||||
focused = true; | ||||
|
r8053 | if (scroller.className.search(/\bCodeMirror-focused\b/) == -1) | ||
scroller.className += " CodeMirror-focused"; | ||||
|
r5941 | if (!leaveInputAlone) resetInput(true); | ||
|
r4504 | } | ||
slowPoll(); | ||||
restartBlink(); | ||||
} | ||||
function onBlur() { | ||||
if (focused) { | ||||
if (options.onBlur) options.onBlur(instance); | ||||
focused = false; | ||||
|
r5970 | if (bracketHighlighted) | ||
operation(function(){ | ||||
if (bracketHighlighted) { bracketHighlighted(); bracketHighlighted = null; } | ||||
})(); | ||||
|
r8053 | scroller.className = scroller.className.replace(" CodeMirror-focused", ""); | ||
|
r4504 | } | ||
clearInterval(blinker); | ||||
setTimeout(function() {if (!focused) shiftSelecting = null;}, 150); | ||||
} | ||||
|
r8053 | function chopDelta(delta) { | ||
// Make sure we always scroll a little bit for any nonzero delta. | ||||
if (delta > 0.0 && delta < 1.0) return 1; | ||||
else if (delta > -1.0 && delta < 0.0) return -1; | ||||
else return Math.round(delta); | ||||
} | ||||
function onMouseWheel(e) { | ||||
var deltaX = 0, deltaY = 0; | ||||
if (e.type == "DOMMouseScroll") { // Firefox | ||||
var delta = -e.detail * 8.0; | ||||
if (e.axis == e.HORIZONTAL_AXIS) deltaX = delta; | ||||
else if (e.axis == e.VERTICAL_AXIS) deltaY = delta; | ||||
} else if (e.wheelDeltaX !== undefined && e.wheelDeltaY !== undefined) { // WebKit | ||||
deltaX = e.wheelDeltaX / 3.0; | ||||
deltaY = e.wheelDeltaY / 3.0; | ||||
} else if (e.wheelDelta !== undefined) { // IE or Opera | ||||
deltaY = e.wheelDelta / 3.0; | ||||
} | ||||
var scrolled = false; | ||||
deltaX = chopDelta(deltaX); | ||||
deltaY = chopDelta(deltaY); | ||||
if ((deltaX > 0 && scroller.scrollLeft > 0) || | ||||
(deltaX < 0 && scroller.scrollLeft + scroller.clientWidth < scroller.scrollWidth)) { | ||||
scroller.scrollLeft -= deltaX; | ||||
scrolled = true; | ||||
} | ||||
if ((deltaY > 0 && scrollbar.scrollTop > 0) || | ||||
(deltaY < 0 && scrollbar.scrollTop + scrollbar.clientHeight < scrollbar.scrollHeight)) { | ||||
scrollbar.scrollTop -= deltaY; | ||||
scrolled = true; | ||||
} | ||||
if (scrolled) e_stop(e); | ||||
} | ||||
|
r4504 | // Replace the range from from to to by the strings in newText. | ||
// Afterwards, set the selection to selFrom, selTo. | ||||
function updateLines(from, to, newText, selFrom, selTo) { | ||||
|
r5970 | if (suppressEdits) return; | ||
|
r4504 | if (history) { | ||
var old = []; | ||||
|
r5941 | doc.iter(from.line, to.line + 1, function(line) { old.push(line.text); }); | ||
|
r4504 | history.addChange(from.line, newText.length, old); | ||
while (history.done.length > options.undoDepth) history.done.shift(); | ||||
} | ||||
updateLinesNoUndo(from, to, newText, selFrom, selTo); | ||||
} | ||||
|
r8053 | function unredoHelper(from, to) { | ||
if (!from.length) return; | ||||
var set = from.pop(), out = []; | ||||
for (var i = set.length - 1; i >= 0; i -= 1) { | ||||
|
r6058 | var change = set[i]; | ||
|
r4504 | var replaced = [], end = change.start + change.added; | ||
|
r5941 | doc.iter(change.start, end, function(line) { replaced.push(line.text); }); | ||
|
r6058 | out.push({start: change.start, added: change.old.length, old: replaced}); | ||
|
r8053 | var pos = {line: change.start + change.old.length - 1, | ||
ch: editEnd(replaced[replaced.length-1], change.old[change.old.length-1])}; | ||||
|
r5941 | updateLinesNoUndo({line: change.start, ch: 0}, {line: end - 1, ch: getLine(end-1).text.length}, change.old, pos, pos); | ||
|
r4504 | } | ||
|
r6058 | updateInput = true; | ||
to.push(out); | ||||
|
r4504 | } | ||
|
r8053 | function undo() {unredoHelper(history.done, history.undone);} | ||
function redo() {unredoHelper(history.undone, history.done);} | ||||
|
r4504 | |||
function updateLinesNoUndo(from, to, newText, selFrom, selTo) { | ||||
|
r5970 | if (suppressEdits) return; | ||
|
r4504 | var recomputeMaxLength = false, maxLineLength = maxLine.length; | ||
|
r5941 | if (!options.lineWrapping) | ||
|
r8053 | doc.iter(from.line, to.line + 1, function(line) { | ||
if (!line.hidden && line.text.length == maxLineLength) {recomputeMaxLength = true; return true;} | ||||
|
r5941 | }); | ||
if (from.line != to.line || newText.length > 1) gutterDirty = true; | ||||
|
r4504 | |||
|
r5941 | var nlines = to.line - from.line, firstLine = getLine(from.line), lastLine = getLine(to.line); | ||
|
r4504 | // First adjust the line structure, taking some care to leave highlighting intact. | ||
|
r5941 | if (from.ch == 0 && to.ch == 0 && newText[newText.length - 1] == "") { | ||
// This is a whole-line replace. Treated specially to make | ||||
// sure line objects move the way they are supposed to. | ||||
var added = [], prevLine = null; | ||||
if (from.line) { | ||||
prevLine = getLine(from.line - 1); | ||||
prevLine.fixMarkEnds(lastLine); | ||||
} else lastLine.fixMarkStarts(); | ||||
for (var i = 0, e = newText.length - 1; i < e; ++i) | ||||
added.push(Line.inheritMarks(newText[i], prevLine)); | ||||
if (nlines) doc.remove(from.line, nlines, callbacks); | ||||
if (added.length) doc.insert(from.line, added); | ||||
} else if (firstLine == lastLine) { | ||||
|
r4504 | if (newText.length == 1) | ||
firstLine.replace(from.ch, to.ch, newText[0]); | ||||
else { | ||||
lastLine = firstLine.split(to.ch, newText[newText.length-1]); | ||||
|
r5941 | firstLine.replace(from.ch, null, newText[0]); | ||
firstLine.fixMarkEnds(lastLine); | ||||
var added = []; | ||||
for (var i = 1, e = newText.length - 1; i < e; ++i) | ||||
added.push(Line.inheritMarks(newText[i], firstLine)); | ||||
added.push(lastLine); | ||||
doc.insert(from.line + 1, added); | ||||
|
r4504 | } | ||
|
r5941 | } else if (newText.length == 1) { | ||
firstLine.replace(from.ch, null, newText[0]); | ||||
lastLine.replace(null, to.ch, ""); | ||||
firstLine.append(lastLine); | ||||
doc.remove(from.line + 1, nlines, callbacks); | ||||
} else { | ||||
var added = []; | ||||
firstLine.replace(from.ch, null, newText[0]); | ||||
lastLine.replace(null, to.ch, newText[newText.length-1]); | ||||
firstLine.fixMarkEnds(lastLine); | ||||
for (var i = 1, e = newText.length - 1; i < e; ++i) | ||||
added.push(Line.inheritMarks(newText[i], firstLine)); | ||||
if (nlines > 1) doc.remove(from.line + 1, nlines - 1, callbacks); | ||||
doc.insert(from.line + 1, added); | ||||
} | ||||
if (options.lineWrapping) { | ||||
|
r8053 | var perLine = Math.max(5, scroller.clientWidth / charWidth() - 3); | ||
|
r5941 | doc.iter(from.line, from.line + newText.length, function(line) { | ||
if (line.hidden) return; | ||||
var guess = Math.ceil(line.text.length / perLine) || 1; | ||||
if (guess != line.height) updateLineHeight(line, guess); | ||||
}); | ||||
} else { | ||||
|
r8053 | doc.iter(from.line, from.line + newText.length, function(line) { | ||
|
r5941 | var l = line.text; | ||
|
r8053 | if (!line.hidden && l.length > maxLineLength) { | ||
maxLine = l; maxLineLength = l.length; maxLineChanged = true; | ||||
|
r5941 | recomputeMaxLength = false; | ||
|
r4504 | } | ||
|
r5941 | }); | ||
|
r8053 | if (recomputeMaxLength) updateMaxLine = true; | ||
|
r4504 | } | ||
// Add these lines to the work array, so that they will be | ||||
// highlighted. Adjust work lines if lines were added/removed. | ||||
var newWork = [], lendiff = newText.length - nlines - 1; | ||||
for (var i = 0, l = work.length; i < l; ++i) { | ||||
var task = work[i]; | ||||
if (task < from.line) newWork.push(task); | ||||
else if (task > to.line) newWork.push(task + lendiff); | ||||
} | ||||
|
r5941 | var hlEnd = from.line + Math.min(newText.length, 500); | ||
highlightLines(from.line, hlEnd); | ||||
newWork.push(hlEnd); | ||||
|
r4504 | work = newWork; | ||
startWorker(100); | ||||
// Remember that these lines changed, for updating the display | ||||
changes.push({from: from.line, to: to.line + 1, diff: lendiff}); | ||||
|
r5941 | var changeObj = {from: from, to: to, text: newText}; | ||
if (textChanged) { | ||||
for (var cur = textChanged; cur.next; cur = cur.next) {} | ||||
cur.next = changeObj; | ||||
} else textChanged = changeObj; | ||||
|
r4504 | |||
// Update the selection | ||||
function updateLine(n) {return n <= Math.min(to.line, to.line + lendiff) ? n : n + lendiff;} | ||||
|
r8053 | setSelection(clipPos(selFrom), clipPos(selTo), | ||
updateLine(sel.from.line), updateLine(sel.to.line)); | ||||
} | ||||
function needsScrollbar() { | ||||
var realHeight = doc.height * textHeight() + 2 * paddingTop(); | ||||
return realHeight - 1 > scroller.offsetHeight ? realHeight : false; | ||||
} | ||||
function updateVerticalScroll(scrollTop) { | ||||
var scrollHeight = needsScrollbar(); | ||||
scrollbar.style.display = scrollHeight ? "block" : "none"; | ||||
if (scrollHeight) { | ||||
scrollbarInner.style.height = scrollHeight + "px"; | ||||
scrollbar.style.height = scroller.offsetHeight + "px"; | ||||
if (scrollTop != null) scrollbar.scrollTop = scrollTop; | ||||
} | ||||
// Position the mover div to align with the current virtual scroll position | ||||
mover.style.top = (displayOffset * textHeight() - scrollbar.scrollTop) + "px"; | ||||
} | ||||
// On Mac OS X Lion and up, detect whether the mouse is plugged in by measuring | ||||
// the width of a div with a scrollbar in it. If the width is <= 1, then | ||||
// the mouse isn't plugged in and scrollbars should overlap the content. | ||||
function overlapScrollbars() { | ||||
var tmpSb = document.createElement('div'), | ||||
tmpSbInner = document.createElement('div'); | ||||
tmpSb.className = "CodeMirror-scrollbar"; | ||||
tmpSb.style.cssText = "position: absolute; left: -9999px; height: 100px;"; | ||||
tmpSbInner.className = "CodeMirror-scrollbar-inner"; | ||||
tmpSbInner.style.height = "200px"; | ||||
tmpSb.appendChild(tmpSbInner); | ||||
document.body.appendChild(tmpSb); | ||||
var result = (tmpSb.offsetWidth <= 1); | ||||
document.body.removeChild(tmpSb); | ||||
return result; | ||||
} | ||||
|
r4504 | |||
|
r8053 | function computeMaxLength() { | ||
var maxLineLength = 0; | ||||
maxLine = ""; maxLineChanged = true; | ||||
doc.iter(0, doc.size, function(line) { | ||||
var l = line.text; | ||||
if (!line.hidden && l.length > maxLineLength) { | ||||
maxLineLength = l.length; maxLine = l; | ||||
} | ||||
}); | ||||
updateMaxLine = false; | ||||
|
r4504 | } | ||
function replaceRange(code, from, to) { | ||||
from = clipPos(from); | ||||
if (!to) to = from; else to = clipPos(to); | ||||
code = splitLines(code); | ||||
function adjustPos(pos) { | ||||
if (posLess(pos, from)) return pos; | ||||
if (!posLess(to, pos)) return end; | ||||
var line = pos.line + code.length - (to.line - from.line) - 1; | ||||
var ch = pos.ch; | ||||
if (pos.line == to.line) | ||||
ch += code[code.length-1].length - (to.ch - (to.line == from.line ? from.ch : 0)); | ||||
return {line: line, ch: ch}; | ||||
} | ||||
var end; | ||||
replaceRange1(code, from, to, function(end1) { | ||||
end = end1; | ||||
return {from: adjustPos(sel.from), to: adjustPos(sel.to)}; | ||||
}); | ||||
return end; | ||||
} | ||||
function replaceSelection(code, collapse) { | ||||
replaceRange1(splitLines(code), sel.from, sel.to, function(end) { | ||||
if (collapse == "end") return {from: end, to: end}; | ||||
else if (collapse == "start") return {from: sel.from, to: sel.from}; | ||||
else return {from: sel.from, to: end}; | ||||
}); | ||||
} | ||||
function replaceRange1(code, from, to, computeSel) { | ||||
var endch = code.length == 1 ? code[0].length + from.ch : code[code.length-1].length; | ||||
var newSel = computeSel({line: from.line + code.length - 1, ch: endch}); | ||||
updateLines(from, to, code, newSel.from, newSel.to); | ||||
} | ||||
|
r8053 | function getRange(from, to, lineSep) { | ||
|
r4504 | var l1 = from.line, l2 = to.line; | ||
|
r5941 | if (l1 == l2) return getLine(l1).text.slice(from.ch, to.ch); | ||
var code = [getLine(l1).text.slice(from.ch)]; | ||||
doc.iter(l1 + 1, l2, function(line) { code.push(line.text); }); | ||||
code.push(getLine(l2).text.slice(0, to.ch)); | ||||
|
r8053 | return code.join(lineSep || "\n"); | ||
|
r4504 | } | ||
|
r8053 | function getSelection(lineSep) { | ||
return getRange(sel.from, sel.to, lineSep); | ||||
|
r4504 | } | ||
var pollingFast = false; // Ensures slowPoll doesn't cancel fastPoll | ||||
function slowPoll() { | ||||
if (pollingFast) return; | ||||
|
r5941 | poll.set(options.pollInterval, function() { | ||
|
r4504 | startOperation(); | ||
readInput(); | ||||
if (focused) slowPoll(); | ||||
endOperation(); | ||||
}); | ||||
} | ||||
|
r5941 | function fastPoll() { | ||
|
r4504 | var missed = false; | ||
pollingFast = true; | ||||
function p() { | ||||
startOperation(); | ||||
var changed = readInput(); | ||||
|
r5941 | if (!changed && !missed) {missed = true; poll.set(60, p);} | ||
|
r4504 | else {pollingFast = false; slowPoll();} | ||
endOperation(); | ||||
} | ||||
poll.set(20, p); | ||||
} | ||||
|
r5941 | // Previnput is a hack to work with IME. If we reset the textarea | ||
// on every change, that breaks IME. So we look for changes | ||||
// compared to the previous content instead. (Modern browsers have | ||||
// events that indicate IME taking place, but these are not widely | ||||
// supported or compatible enough yet to rely on.) | ||||
var prevInput = ""; | ||||
|
r4504 | function readInput() { | ||
|
r5970 | if (leaveInputAlone || !focused || hasSelection(input) || options.readOnly) return false; | ||
|
r5941 | var text = input.value; | ||
if (text == prevInput) return false; | ||||
shiftSelecting = null; | ||||
var same = 0, l = Math.min(prevInput.length, text.length); | ||||
while (same < l && prevInput[same] == text[same]) ++same; | ||||
if (same < prevInput.length) | ||||
sel.from = {line: sel.from.line, ch: sel.from.ch - (prevInput.length - same)}; | ||||
else if (overwrite && posEq(sel.from, sel.to)) | ||||
sel.to = {line: sel.to.line, ch: Math.min(getLine(sel.to.line).text.length, sel.to.ch + (text.length - same))}; | ||||
replaceSelection(text.slice(same), "end"); | ||||
|
r8053 | if (text.length > 1000) { input.value = prevInput = ""; } | ||
else prevInput = text; | ||||
|
r5941 | return true; | ||
|
r4504 | } | ||
|
r5941 | function resetInput(user) { | ||
if (!posEq(sel.from, sel.to)) { | ||||
prevInput = ""; | ||||
input.value = getSelection(); | ||||
|
r6058 | selectInput(input); | ||
|
r5941 | } else if (user) prevInput = input.value = ""; | ||
|
r4504 | } | ||
|
r5941 | |||
|
r4504 | function focusInput() { | ||
|
r5970 | if (options.readOnly != "nocursor") input.focus(); | ||
|
r4504 | } | ||
|
r4933 | function scrollEditorIntoView() { | ||
var rect = cursor.getBoundingClientRect(); | ||||
|
r5941 | // IE returns bogus coordinates when the instance sits inside of an iframe and the cursor is hidden | ||
if (ie && rect.top == rect.bottom) return; | ||||
var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight); | ||||
|
r8053 | if (rect.top < 0 || rect.bottom > winH) scrollCursorIntoView(); | ||
|
r4933 | } | ||
|
r4504 | function scrollCursorIntoView() { | ||
|
r8053 | var coords = calculateCursorCoords(); | ||
return scrollIntoView(coords.x, coords.y, coords.x, coords.yBot); | ||||
} | ||||
function calculateCursorCoords() { | ||||
|
r4504 | var cursor = localCoords(sel.inverted ? sel.from : sel.to); | ||
|
r5941 | var x = options.lineWrapping ? Math.min(cursor.x, lineSpace.offsetWidth) : cursor.x; | ||
|
r8053 | return {x: x, y: cursor.y, yBot: cursor.yBot}; | ||
|
r4504 | } | ||
function scrollIntoView(x1, y1, x2, y2) { | ||||
|
r8053 | var scrollPos = calculateScrollPos(x1, y1, x2, y2), scrolled = false; | ||
if (scrollPos.scrollLeft != null) {scroller.scrollLeft = scrollPos.scrollLeft; scrolled = true;} | ||||
if (scrollPos.scrollTop != null) {scrollbar.scrollTop = scrollPos.scrollTop; scrolled = true;} | ||||
if (scrolled && options.onScroll) options.onScroll(instance); | ||||
} | ||||
function calculateScrollPos(x1, y1, x2, y2) { | ||||
var pl = paddingLeft(), pt = paddingTop(); | ||||
|
r4504 | y1 += pt; y2 += pt; x1 += pl; x2 += pl; | ||
|
r8053 | var screen = scroller.clientHeight, screentop = scrollbar.scrollTop, result = {}; | ||
var docBottom = scroller.scrollHeight; | ||||
var atTop = y1 < pt + 10, atBottom = y2 + pt > docBottom - 10;; | ||||
if (y1 < screentop) result.scrollTop = atTop ? 0 : Math.max(0, y1); | ||||
else if (y2 > screentop + screen) result.scrollTop = (atBottom ? docBottom : y2) - screen; | ||||
|
r4504 | |||
var screenw = scroller.clientWidth, screenleft = scroller.scrollLeft; | ||||
|
r4933 | var gutterw = options.fixedGutter ? gutter.clientWidth : 0; | ||
|
r8053 | var atLeft = x1 < gutterw + pl + 10; | ||
if (x1 < screenleft + gutterw || atLeft) { | ||||
if (atLeft) x1 = 0; | ||||
result.scrollLeft = Math.max(0, x1 - 10 - gutterw); | ||||
} else if (x2 > screenw + screenleft - 3) { | ||||
result.scrollLeft = x2 + 10 - screenw; | ||||
|
r4504 | } | ||
return result; | ||||
} | ||||
|
r8053 | function visibleLines(scrollTop) { | ||
var lh = textHeight(), top = (scrollTop != null ? scrollTop : scrollbar.scrollTop) - paddingTop(); | ||||
var fromHeight = Math.max(0, Math.floor(top / lh)); | ||||
var toHeight = Math.ceil((top + scroller.clientHeight) / lh); | ||||
return {from: lineAtHeight(doc, fromHeight), | ||||
to: lineAtHeight(doc, toHeight)}; | ||||
|
r4504 | } | ||
// Uses a set of changes plus the current scroll position to | ||||
// determine which DOM updates have to be made, and makes the | ||||
// updates. | ||||
|
r8053 | function updateDisplay(changes, suppressCallback, scrollTop) { | ||
|
r4504 | if (!scroller.clientWidth) { | ||
|
r5941 | showingFrom = showingTo = displayOffset = 0; | ||
|
r4504 | return; | ||
} | ||||
|
r5941 | // Compute the new visible window | ||
|
r8053 | // If scrollTop is specified, use that to determine which lines | ||
// to render instead of the current scrollbar position. | ||||
var visible = visibleLines(scrollTop); | ||||
|
r5941 | // Bail out if the visible area is already rendered and nothing changed. | ||
|
r8053 | if (changes !== true && changes.length == 0 && visible.from > showingFrom && visible.to < showingTo) { | ||
updateVerticalScroll(scrollTop); | ||||
return; | ||||
} | ||||
|
r5941 | var from = Math.max(visible.from - 100, 0), to = Math.min(doc.size, visible.to + 100); | ||
if (showingFrom < from && from - showingFrom < 20) from = showingFrom; | ||||
if (showingTo > to && showingTo - to < 20) to = Math.min(doc.size, showingTo); | ||||
// Create a range of theoretically intact lines, and punch holes | ||||
// in that using the change info. | ||||
var intact = changes === true ? [] : | ||||
computeIntact([{from: showingFrom, to: showingTo, domStart: 0}], changes); | ||||
// Clip off the parts that won't be visible | ||||
var intactLines = 0; | ||||
for (var i = 0; i < intact.length; ++i) { | ||||
var range = intact[i]; | ||||
if (range.from < from) {range.domStart += (from - range.from); range.from = from;} | ||||
if (range.to > to) range.to = to; | ||||
if (range.from >= range.to) intact.splice(i--, 1); | ||||
else intactLines += range.to - range.from; | ||||
} | ||||
|
r8053 | if (intactLines == to - from && from == showingFrom && to == showingTo) { | ||
updateVerticalScroll(scrollTop); | ||||
return; | ||||
} | ||||
|
r5941 | intact.sort(function(a, b) {return a.domStart - b.domStart;}); | ||
var th = textHeight(), gutterDisplay = gutter.style.display; | ||||
|
r5970 | lineDiv.style.display = "none"; | ||
|
r5941 | patchDisplay(from, to, intact); | ||
|
r5970 | lineDiv.style.display = gutter.style.display = ""; | ||
|
r5941 | |||
var different = from != showingFrom || to != showingTo || lastSizeC != scroller.clientHeight + th; | ||||
// This is just a bogus formula that detects when the editor is | ||||
// resized or the font size changes. | ||||
if (different) lastSizeC = scroller.clientHeight + th; | ||||
showingFrom = from; showingTo = to; | ||||
displayOffset = heightAtLine(doc, from); | ||||
// Since this is all rather error prone, it is honoured with the | ||||
// only assertion in the whole file. | ||||
if (lineDiv.childNodes.length != showingTo - showingFrom) | ||||
throw new Error("BAD PATCH! " + JSON.stringify(intact) + " size=" + (showingTo - showingFrom) + | ||||
" nodes=" + lineDiv.childNodes.length); | ||||
|
r8053 | function checkHeights() { | ||
|
r5970 | var curNode = lineDiv.firstChild, heightChanged = false; | ||
|
r5941 | doc.iter(showingFrom, showingTo, function(line) { | ||
if (!line.hidden) { | ||||
var height = Math.round(curNode.offsetHeight / th) || 1; | ||||
|
r5970 | if (line.height != height) { | ||
updateLineHeight(line, height); | ||||
gutterDirty = heightChanged = true; | ||||
} | ||||
|
r5941 | } | ||
curNode = curNode.nextSibling; | ||||
}); | ||||
|
r8053 | return heightChanged; | ||
} | ||||
if (options.lineWrapping) { | ||||
checkHeights(); | ||||
var scrollHeight = needsScrollbar(); | ||||
var shouldHaveScrollbar = scrollHeight ? "block" : "none"; | ||||
if (scrollbar.style.display != shouldHaveScrollbar) { | ||||
scrollbar.style.display = shouldHaveScrollbar; | ||||
if (scrollHeight) scrollbarInner.style.height = scrollHeight + "px"; | ||||
checkHeights(); | ||||
|
r5941 | } | ||
} | ||||
|
r8053 | |||
|
r5941 | gutter.style.display = gutterDisplay; | ||
|
r8053 | if (different || gutterDirty) { | ||
// If the gutter grew in size, re-check heights. If those changed, re-draw gutter. | ||||
updateGutter() && options.lineWrapping && checkHeights() && updateGutter(); | ||||
} | ||||
updateVerticalScroll(scrollTop); | ||||
|
r5970 | updateSelection(); | ||
|
r5941 | if (!suppressCallback && options.onUpdate) options.onUpdate(instance); | ||
return true; | ||||
} | ||||
function computeIntact(intact, changes) { | ||||
|
r4504 | for (var i = 0, l = changes.length || 0; i < l; ++i) { | ||
var change = changes[i], intact2 = [], diff = change.diff || 0; | ||||
for (var j = 0, l2 = intact.length; j < l2; ++j) { | ||||
var range = intact[j]; | ||||
|
r5941 | if (change.to <= range.from && change.diff) | ||
intact2.push({from: range.from + diff, to: range.to + diff, | ||||
domStart: range.domStart}); | ||||
else if (change.to <= range.from || change.from >= range.to) | ||||
|
r4504 | intact2.push(range); | ||
else { | ||||
if (change.from > range.from) | ||||
|
r5941 | intact2.push({from: range.from, to: change.from, domStart: range.domStart}); | ||
|
r4504 | if (change.to < range.to) | ||
intact2.push({from: change.to + diff, to: range.to + diff, | ||||
domStart: range.domStart + (change.to - range.from)}); | ||||
} | ||||
} | ||||
intact = intact2; | ||||
} | ||||
|
r5941 | return intact; | ||
} | ||||
|
r4504 | |||
|
r5941 | function patchDisplay(from, to, intact) { | ||
// The first pass removes the DOM nodes that aren't intact. | ||||
if (!intact.length) lineDiv.innerHTML = ""; | ||||
else { | ||||
function killNode(node) { | ||||
var tmp = node.nextSibling; | ||||
node.parentNode.removeChild(node); | ||||
return tmp; | ||||
|
r4504 | } | ||
|
r5941 | var domPos = 0, curNode = lineDiv.firstChild, n; | ||
for (var i = 0; i < intact.length; ++i) { | ||||
var cur = intact[i]; | ||||
while (cur.domStart > domPos) {curNode = killNode(curNode); domPos++;} | ||||
for (var j = 0, e = cur.to - cur.from; j < e; ++j) {curNode = curNode.nextSibling; domPos++;} | ||||
} | ||||
while (curNode) curNode = killNode(curNode); | ||||
|
r4504 | } | ||
|
r5941 | // This pass fills in the lines that actually changed. | ||
var nextIntact = intact.shift(), curNode = lineDiv.firstChild, j = from; | ||||
|
r8053 | var scratch = document.createElement("div"); | ||
|
r5941 | doc.iter(from, to, function(line) { | ||
if (nextIntact && nextIntact.to == j) nextIntact = intact.shift(); | ||||
if (!nextIntact || nextIntact.from > j) { | ||||
|
r5970 | if (line.hidden) var html = scratch.innerHTML = "<pre></pre>"; | ||
else { | ||||
|
r8053 | var html = '<pre' + (line.className ? ' class="' + line.className + '"' : '') + '>' | ||
+ line.getHTML(makeTab) + '</pre>'; | ||||
|
r5970 | // Kludge to make sure the styled element lies behind the selection (by z-index) | ||
|
r8053 | if (line.bgClassName) | ||
html = '<div style="position: relative"><pre class="' + line.bgClassName + | ||||
|
r5970 | '" style="position: absolute; left: 0; right: 0; top: 0; bottom: 0; z-index: -2"> </pre>' + html + "</div>"; | ||
} | ||||
scratch.innerHTML = html; | ||||
|
r5941 | lineDiv.insertBefore(scratch.firstChild, curNode); | ||
} else { | ||||
curNode = curNode.nextSibling; | ||||
|
r4504 | } | ||
|
r5941 | ++j; | ||
}); | ||||
|
r4504 | } | ||
function updateGutter() { | ||||
if (!options.gutter && !options.lineNumbers) return; | ||||
var hText = mover.offsetHeight, hEditor = scroller.clientHeight; | ||||
gutter.style.height = (hText - hEditor < 2 ? hEditor : hText) + "px"; | ||||
|
r8053 | var html = [], i = showingFrom, normalNode; | ||
|
r5941 | doc.iter(showingFrom, Math.max(showingTo, showingFrom + 1), function(line) { | ||
if (line.hidden) { | ||||
html.push("<pre></pre>"); | ||||
} else { | ||||
var marker = line.gutterMarker; | ||||
|
r8053 | var text = options.lineNumbers ? options.lineNumberFormatter(i + options.firstLineNumber) : null; | ||
|
r5941 | if (marker && marker.text) | ||
text = marker.text.replace("%N%", text != null ? text : ""); | ||||
else if (text == null) | ||||
text = "\u00a0"; | ||||
html.push((marker && marker.style ? '<pre class="' + marker.style + '">' : "<pre>"), text); | ||||
for (var j = 1; j < line.height; ++j) html.push("<br/> "); | ||||
html.push("</pre>"); | ||||
|
r8053 | if (!marker) normalNode = i; | ||
|
r5941 | } | ||
++i; | ||||
}); | ||||
|
r4504 | gutter.style.display = "none"; | ||
gutterText.innerHTML = html.join(""); | ||||
|
r8053 | // Make sure scrolling doesn't cause number gutter size to pop | ||
if (normalNode != null && options.lineNumbers) { | ||||
var node = gutterText.childNodes[normalNode - showingFrom]; | ||||
var minwidth = String(doc.size).length, val = eltText(node.firstChild), pad = ""; | ||||
while (val.length + pad.length < minwidth) pad += "\u00a0"; | ||||
if (pad) node.insertBefore(document.createTextNode(pad), node.firstChild); | ||||
} | ||||
|
r4504 | gutter.style.display = ""; | ||
|
r8053 | var resized = Math.abs((parseInt(lineSpace.style.marginLeft) || 0) - gutter.offsetWidth) > 2; | ||
|
r4504 | lineSpace.style.marginLeft = gutter.offsetWidth + "px"; | ||
|
r4933 | gutterDirty = false; | ||
|
r8053 | return resized; | ||
|
r4504 | } | ||
|
r5970 | function updateSelection() { | ||
var collapsed = posEq(sel.from, sel.to); | ||||
var fromPos = localCoords(sel.from, true); | ||||
var toPos = collapsed ? fromPos : localCoords(sel.to, true); | ||||
var headPos = sel.inverted ? fromPos : toPos, th = textHeight(); | ||||
|
r5941 | var wrapOff = eltOffset(wrapper), lineOff = eltOffset(lineDiv); | ||
|
r5970 | inputDiv.style.top = Math.max(0, Math.min(scroller.offsetHeight, headPos.y + lineOff.top - wrapOff.top)) + "px"; | ||
inputDiv.style.left = Math.max(0, Math.min(scroller.offsetWidth, headPos.x + lineOff.left - wrapOff.left)) + "px"; | ||||
if (collapsed) { | ||||
cursor.style.top = headPos.y + "px"; | ||||
cursor.style.left = (options.lineWrapping ? Math.min(headPos.x, lineSpace.offsetWidth) : headPos.x) + "px"; | ||||
|
r4504 | cursor.style.display = ""; | ||
|
r5970 | selectionDiv.style.display = "none"; | ||
} else { | ||||
var sameLine = fromPos.y == toPos.y, html = ""; | ||||
|
r8053 | var clientWidth = lineSpace.clientWidth || lineSpace.offsetWidth; | ||
var clientHeight = lineSpace.clientHeight || lineSpace.offsetHeight; | ||||
|
r5970 | function add(left, top, right, height) { | ||
|
r8053 | var rstyle = quirksMode ? "width: " + (!right ? clientWidth : clientWidth - right - left) + "px" | ||
: "right: " + right + "px"; | ||||
|
r5970 | html += '<div class="CodeMirror-selected" style="position: absolute; left: ' + left + | ||
|
r8053 | 'px; top: ' + top + 'px; ' + rstyle + '; height: ' + height + 'px"></div>'; | ||
|
r5970 | } | ||
if (sel.from.ch && fromPos.y >= 0) { | ||||
|
r8053 | var right = sameLine ? clientWidth - toPos.x : 0; | ||
|
r5970 | add(fromPos.x, fromPos.y, right, th); | ||
} | ||||
var middleStart = Math.max(0, fromPos.y + (sel.from.ch ? th : 0)); | ||||
|
r8053 | var middleHeight = Math.min(toPos.y, clientHeight) - middleStart; | ||
|
r5970 | if (middleHeight > 0.2 * th) | ||
add(0, middleStart, 0, middleHeight); | ||||
|
r8053 | if ((!sameLine || !sel.from.ch) && toPos.y < clientHeight - .5 * th) | ||
add(0, toPos.y, clientWidth - toPos.x, th); | ||||
|
r5970 | selectionDiv.innerHTML = html; | ||
cursor.style.display = "none"; | ||||
selectionDiv.style.display = ""; | ||||
|
r4504 | } | ||
} | ||||
|
r5941 | function setShift(val) { | ||
if (val) shiftSelecting = shiftSelecting || (sel.inverted ? sel.to : sel.from); | ||||
else shiftSelecting = null; | ||||
} | ||||
|
r4504 | function setSelectionUser(from, to) { | ||
var sh = shiftSelecting && clipPos(shiftSelecting); | ||||
if (sh) { | ||||
if (posLess(sh, from)) from = sh; | ||||
else if (posLess(to, sh)) to = sh; | ||||
} | ||||
setSelection(from, to); | ||||
|
r5941 | userSelChange = true; | ||
|
r4504 | } | ||
// Update the selection. Last two args are only used by | ||||
// updateLines, since they have to be expressed in the line | ||||
// numbers before the update. | ||||
function setSelection(from, to, oldFrom, oldTo) { | ||||
|
r5941 | goalColumn = null; | ||
if (oldFrom == null) {oldFrom = sel.from.line; oldTo = sel.to.line;} | ||||
|
r4504 | if (posEq(sel.from, from) && posEq(sel.to, to)) return; | ||
if (posLess(to, from)) {var tmp = to; to = from; from = tmp;} | ||||
|
r5941 | // Skip over hidden lines. | ||
|
r8053 | if (from.line != oldFrom) { | ||
var from1 = skipHidden(from, oldFrom, sel.from.ch); | ||||
// If there is no non-hidden line left, force visibility on current line | ||||
if (!from1) setLineHidden(from.line, false); | ||||
else from = from1; | ||||
} | ||||
|
r5941 | if (to.line != oldTo) to = skipHidden(to, oldTo, sel.to.ch); | ||
|
r4504 | if (posEq(from, to)) sel.inverted = false; | ||
else if (posEq(from, sel.to)) sel.inverted = false; | ||||
else if (posEq(to, sel.from)) sel.inverted = true; | ||||
|
r8053 | if (options.autoClearEmptyLines && posEq(sel.from, sel.to)) { | ||
var head = sel.inverted ? from : to; | ||||
if (head.line != sel.from.line && sel.from.line < doc.size) { | ||||
var oldLine = getLine(sel.from.line); | ||||
if (/^\s+$/.test(oldLine.text)) | ||||
setTimeout(operation(function() { | ||||
if (oldLine.parent && /^\s+$/.test(oldLine.text)) { | ||||
var no = lineNo(oldLine); | ||||
replaceRange("", {line: no, ch: 0}, {line: no, ch: oldLine.text.length}); | ||||
} | ||||
}, 10)); | ||||
} | ||||
} | ||||
|
r4504 | sel.from = from; sel.to = to; | ||
selectionChanged = true; | ||||
} | ||||
|
r5941 | function skipHidden(pos, oldLine, oldCh) { | ||
function getNonHidden(dir) { | ||||
var lNo = pos.line + dir, end = dir == 1 ? doc.size : -1; | ||||
while (lNo != end) { | ||||
var line = getLine(lNo); | ||||
if (!line.hidden) { | ||||
var ch = pos.ch; | ||||
|
r8053 | if (toEnd || ch > oldCh || ch > line.text.length) ch = line.text.length; | ||
|
r5941 | return {line: lNo, ch: ch}; | ||
} | ||||
lNo += dir; | ||||
} | ||||
} | ||||
var line = getLine(pos.line); | ||||
|
r8053 | var toEnd = pos.ch == line.text.length && pos.ch != oldCh; | ||
|
r5941 | if (!line.hidden) return pos; | ||
if (pos.line >= oldLine) return getNonHidden(1) || getNonHidden(-1); | ||||
else return getNonHidden(-1) || getNonHidden(1); | ||||
} | ||||
|
r4504 | function setCursor(line, ch, user) { | ||
var pos = clipPos({line: line, ch: ch || 0}); | ||||
(user ? setSelectionUser : setSelection)(pos, pos); | ||||
} | ||||
|
r5941 | function clipLine(n) {return Math.max(0, Math.min(n, doc.size-1));} | ||
|
r4504 | function clipPos(pos) { | ||
if (pos.line < 0) return {line: 0, ch: 0}; | ||||
|
r5941 | if (pos.line >= doc.size) return {line: doc.size-1, ch: getLine(doc.size-1).text.length}; | ||
var ch = pos.ch, linelen = getLine(pos.line).text.length; | ||||
|
r4504 | if (ch == null || ch > linelen) return {line: pos.line, ch: linelen}; | ||
else if (ch < 0) return {line: pos.line, ch: 0}; | ||||
else return pos; | ||||
} | ||||
|
r5941 | function findPosH(dir, unit) { | ||
var end = sel.inverted ? sel.from : sel.to, line = end.line, ch = end.ch; | ||||
var lineObj = getLine(line); | ||||
function findNextLine() { | ||||
for (var l = line + dir, e = dir < 0 ? -1 : doc.size; l != e; l += dir) { | ||||
var lo = getLine(l); | ||||
if (!lo.hidden) { line = l; lineObj = lo; return true; } | ||||
} | ||||
} | ||||
function moveOnce(boundToLine) { | ||||
if (ch == (dir < 0 ? 0 : lineObj.text.length)) { | ||||
if (!boundToLine && findNextLine()) ch = dir < 0 ? lineObj.text.length : 0; | ||||
else return false; | ||||
} else ch += dir; | ||||
return true; | ||||
} | ||||
if (unit == "char") moveOnce(); | ||||
else if (unit == "column") moveOnce(true); | ||||
else if (unit == "word") { | ||||
var sawWord = false; | ||||
for (;;) { | ||||
if (dir < 0) if (!moveOnce()) break; | ||||
if (isWordChar(lineObj.text.charAt(ch))) sawWord = true; | ||||
else if (sawWord) {if (dir < 0) {dir = 1; moveOnce();} break;} | ||||
if (dir > 0) if (!moveOnce()) break; | ||||
} | ||||
} | ||||
return {line: line, ch: ch}; | ||||
|
r4504 | } | ||
|
r5941 | function moveH(dir, unit) { | ||
var pos = dir < 0 ? sel.from : sel.to; | ||||
if (shiftSelecting || posEq(sel.from, sel.to)) pos = findPosH(dir, unit); | ||||
setCursor(pos.line, pos.ch, true); | ||||
|
r4504 | } | ||
|
r5941 | function deleteH(dir, unit) { | ||
if (!posEq(sel.from, sel.to)) replaceRange("", sel.from, sel.to); | ||||
else if (dir < 0) replaceRange("", findPosH(dir, unit), sel.to); | ||||
else replaceRange("", sel.from, findPosH(dir, unit)); | ||||
userSelChange = true; | ||||
|
r4504 | } | ||
|
r5941 | var goalColumn = null; | ||
function moveV(dir, unit) { | ||||
var dist = 0, pos = localCoords(sel.inverted ? sel.from : sel.to, true); | ||||
if (goalColumn != null) pos.x = goalColumn; | ||||
|
r5970 | if (unit == "page") dist = Math.min(scroller.clientHeight, window.innerHeight || document.documentElement.clientHeight); | ||
|
r5941 | else if (unit == "line") dist = textHeight(); | ||
var target = coordsChar(pos.x, pos.y + dist * dir + 2); | ||||
|
r8053 | if (unit == "page") scrollbar.scrollTop += localCoords(target, true).y - pos.y; | ||
|
r5941 | setCursor(target.line, target.ch, true); | ||
goalColumn = pos.x; | ||||
} | ||||
|
r8053 | function findWordAt(pos) { | ||
|
r5941 | var line = getLine(pos.line).text; | ||
|
r4504 | var start = pos.ch, end = pos.ch; | ||
|
r8053 | var check = isWordChar(line.charAt(start < line.length ? start : start - 1)) ? | ||
isWordChar : function(ch) {return !isWordChar(ch);}; | ||||
while (start > 0 && check(line.charAt(start - 1))) --start; | ||||
while (end < line.length && check(line.charAt(end))) ++end; | ||||
return {from: {line: pos.line, ch: start}, to: {line: pos.line, ch: end}}; | ||||
|
r4504 | } | ||
function selectLine(line) { | ||||
|
r8053 | setSelectionUser({line: line, ch: 0}, clipPos({line: line + 1, ch: 0})); | ||
|
r4504 | } | ||
|
r5941 | function indentSelected(mode) { | ||
if (posEq(sel.from, sel.to)) return indentLine(sel.from.line, mode); | ||||
var e = sel.to.line - (sel.to.ch ? 0 : 1); | ||||
for (var i = sel.from.line; i <= e; ++i) indentLine(i, mode); | ||||
|
r4933 | } | ||
|
r4504 | |||
function indentLine(n, how) { | ||||
|
r5941 | if (!how) how = "add"; | ||
|
r4504 | if (how == "smart") { | ||
if (!mode.indent) how = "prev"; | ||||
else var state = getStateBefore(n); | ||||
} | ||||
|
r5941 | var line = getLine(n), curSpace = line.indentation(options.tabSize), | ||
curSpaceString = line.text.match(/^\s*/)[0], indentation; | ||||
|
r8053 | if (how == "smart") { | ||
indentation = mode.indent(state, line.text.slice(curSpaceString.length), line.text); | ||||
if (indentation == Pass) how = "prev"; | ||||
} | ||||
|
r4504 | if (how == "prev") { | ||
|
r5941 | if (n) indentation = getLine(n-1).indentation(options.tabSize); | ||
|
r4504 | else indentation = 0; | ||
} | ||||
else if (how == "add") indentation = curSpace + options.indentUnit; | ||||
else if (how == "subtract") indentation = curSpace - options.indentUnit; | ||||
indentation = Math.max(0, indentation); | ||||
var diff = indentation - curSpace; | ||||
|
r8053 | var indentString = "", pos = 0; | ||
if (options.indentWithTabs) | ||||
for (var i = Math.floor(indentation / options.tabSize); i; --i) {pos += options.tabSize; indentString += "\t";} | ||||
while (pos < indentation) {++pos; indentString += " ";} | ||||
|
r4504 | |||
replaceRange(indentString, {line: n, ch: 0}, {line: n, ch: curSpaceString.length}); | ||||
} | ||||
function loadMode() { | ||||
mode = CodeMirror.getMode(options, options.mode); | ||||
|
r5941 | doc.iter(0, doc.size, function(line) { line.stateAfter = null; }); | ||
|
r4504 | work = [0]; | ||
startWorker(); | ||||
} | ||||
function gutterChanged() { | ||||
var visible = options.gutter || options.lineNumbers; | ||||
gutter.style.display = visible ? "" : "none"; | ||||
|
r4933 | if (visible) gutterDirty = true; | ||
|
r4504 | else lineDiv.parentNode.style.marginLeft = 0; | ||
} | ||||
|
r5941 | function wrappingChanged(from, to) { | ||
if (options.lineWrapping) { | ||||
wrapper.className += " CodeMirror-wrap"; | ||||
var perLine = scroller.clientWidth / charWidth() - 3; | ||||
doc.iter(0, doc.size, function(line) { | ||||
if (line.hidden) return; | ||||
var guess = Math.ceil(line.text.length / perLine) || 1; | ||||
if (guess != 1) updateLineHeight(line, guess); | ||||
}); | ||||
lineSpace.style.width = code.style.width = ""; | ||||
|
r8053 | widthForcer.style.left = ""; | ||
|
r5941 | } else { | ||
wrapper.className = wrapper.className.replace(" CodeMirror-wrap", ""); | ||||
|
r8053 | maxLine = ""; maxLineChanged = true; | ||
|
r5941 | doc.iter(0, doc.size, function(line) { | ||
if (line.height != 1 && !line.hidden) updateLineHeight(line, 1); | ||||
if (line.text.length > maxLine.length) maxLine = line.text; | ||||
}); | ||||
} | ||||
changes.push({from: 0, to: doc.size}); | ||||
} | ||||
|
r8053 | function makeTab(col) { | ||
var w = options.tabSize - col % options.tabSize, cached = tabCache[w]; | ||||
if (cached) return cached; | ||||
for (var str = '<span class="cm-tab">', i = 0; i < w; ++i) str += " "; | ||||
return (tabCache[w] = {html: str + "</span>", width: w}); | ||||
|
r5941 | } | ||
function themeChanged() { | ||||
|
r8053 | scroller.className = scroller.className.replace(/\s*cm-s-\S+/g, "") + | ||
|
r5941 | options.theme.replace(/(^|\s)\s*/g, " cm-s-"); | ||
} | ||||
|
r8053 | function keyMapChanged() { | ||
var style = keyMap[options.keyMap].style; | ||||
wrapper.className = wrapper.className.replace(/\s*cm-keymap-\S+/g, "") + | ||||
(style ? " cm-keymap-" + style : ""); | ||||
} | ||||
|
r5941 | |||
function TextMarker() { this.set = []; } | ||||
TextMarker.prototype.clear = operation(function() { | ||||
var min = Infinity, max = -Infinity; | ||||
for (var i = 0, e = this.set.length; i < e; ++i) { | ||||
var line = this.set[i], mk = line.marked; | ||||
if (!mk || !line.parent) continue; | ||||
var lineN = lineNo(line); | ||||
min = Math.min(min, lineN); max = Math.max(max, lineN); | ||||
for (var j = 0; j < mk.length; ++j) | ||||
|
r8053 | if (mk[j].marker == this) mk.splice(j--, 1); | ||
|
r5941 | } | ||
if (min != Infinity) | ||||
changes.push({from: min, to: max + 1}); | ||||
}); | ||||
TextMarker.prototype.find = function() { | ||||
var from, to; | ||||
for (var i = 0, e = this.set.length; i < e; ++i) { | ||||
var line = this.set[i], mk = line.marked; | ||||
for (var j = 0; j < mk.length; ++j) { | ||||
var mark = mk[j]; | ||||
|
r8053 | if (mark.marker == this) { | ||
|
r5941 | if (mark.from != null || mark.to != null) { | ||
var found = lineNo(line); | ||||
if (found != null) { | ||||
if (mark.from != null) from = {line: found, ch: mark.from}; | ||||
if (mark.to != null) to = {line: found, ch: mark.to}; | ||||
} | ||||
} | ||||
} | ||||
} | ||||
} | ||||
return {from: from, to: to}; | ||||
}; | ||||
|
r4504 | |||
function markText(from, to, className) { | ||||
from = clipPos(from); to = clipPos(to); | ||||
|
r5941 | var tm = new TextMarker(); | ||
|
r8053 | if (!posLess(from, to)) return tm; | ||
|
r4504 | function add(line, from, to, className) { | ||
|
r8053 | getLine(line).addMark(new MarkedText(from, to, className, tm)); | ||
|
r4504 | } | ||
if (from.line == to.line) add(from.line, from.ch, to.ch, className); | ||||
else { | ||||
add(from.line, from.ch, null, className); | ||||
for (var i = from.line + 1, e = to.line; i < e; ++i) | ||||
|
r5941 | add(i, null, null, className); | ||
add(to.line, null, to.ch, className); | ||||
|
r4504 | } | ||
changes.push({from: from.line, to: to.line + 1}); | ||||
|
r5941 | return tm; | ||
} | ||||
function setBookmark(pos) { | ||||
pos = clipPos(pos); | ||||
var bm = new Bookmark(pos.ch); | ||||
getLine(pos.line).addMark(bm); | ||||
return bm; | ||||
|
r4504 | } | ||
|
r8053 | function findMarksAt(pos) { | ||
pos = clipPos(pos); | ||||
var markers = [], marked = getLine(pos.line).marked; | ||||
if (!marked) return markers; | ||||
for (var i = 0, e = marked.length; i < e; ++i) { | ||||
var m = marked[i]; | ||||
if ((m.from == null || m.from <= pos.ch) && | ||||
(m.to == null || m.to >= pos.ch)) | ||||
markers.push(m.marker || m); | ||||
} | ||||
return markers; | ||||
} | ||||
|
r4504 | function addGutterMarker(line, text, className) { | ||
|
r5941 | if (typeof line == "number") line = getLine(clipLine(line)); | ||
|
r4504 | line.gutterMarker = {text: text, style: className}; | ||
|
r4933 | gutterDirty = true; | ||
|
r4504 | return line; | ||
} | ||||
function removeGutterMarker(line) { | ||||
|
r5941 | if (typeof line == "number") line = getLine(clipLine(line)); | ||
|
r4504 | line.gutterMarker = null; | ||
|
r4933 | gutterDirty = true; | ||
|
r4504 | } | ||
|
r5941 | |||
function changeLine(handle, op) { | ||||
var no = handle, line = handle; | ||||
if (typeof handle == "number") line = getLine(clipLine(handle)); | ||||
else no = lineNo(handle); | ||||
if (no == null) return null; | ||||
if (op(line, no)) changes.push({from: no, to: no + 1}); | ||||
else return null; | ||||
|
r4504 | return line; | ||
} | ||||
|
r8053 | function setLineClass(handle, className, bgClassName) { | ||
|
r5941 | return changeLine(handle, function(line) { | ||
|
r8053 | if (line.className != className || line.bgClassName != bgClassName) { | ||
|
r5941 | line.className = className; | ||
|
r8053 | line.bgClassName = bgClassName; | ||
|
r5941 | return true; | ||
} | ||||
}); | ||||
} | ||||
function setLineHidden(handle, hidden) { | ||||
return changeLine(handle, function(line, no) { | ||||
if (line.hidden != hidden) { | ||||
line.hidden = hidden; | ||||
|
r8053 | if (!options.lineWrapping) { | ||
var l = line.text; | ||||
if (hidden && l.length == maxLine.length) { | ||||
updateMaxLine = true; | ||||
} else if (!hidden && l.length > maxLine.length) { | ||||
maxLine = l; updateMaxLine = false; | ||||
} | ||||
} | ||||
|
r5941 | updateLineHeight(line, hidden ? 0 : 1); | ||
|
r5970 | var fline = sel.from.line, tline = sel.to.line; | ||
if (hidden && (fline == no || tline == no)) { | ||||
var from = fline == no ? skipHidden({line: fline, ch: 0}, fline, 0) : sel.from; | ||||
var to = tline == no ? skipHidden({line: tline, ch: 0}, tline, 0) : sel.to; | ||||
|
r8053 | // Can't hide the last visible line, we'd have no place to put the cursor | ||
if (!to) return; | ||||
|
r5970 | setSelection(from, to); | ||
} | ||||
|
r5941 | return (gutterDirty = true); | ||
} | ||||
}); | ||||
} | ||||
|
r4504 | |||
function lineInfo(line) { | ||||
if (typeof line == "number") { | ||||
|
r5941 | if (!isLine(line)) return null; | ||
|
r4504 | var n = line; | ||
|
r5941 | line = getLine(line); | ||
|
r4504 | if (!line) return null; | ||
|
r8053 | } else { | ||
|
r5941 | var n = lineNo(line); | ||
if (n == null) return null; | ||||
|
r4504 | } | ||
var marker = line.gutterMarker; | ||||
|
r5941 | return {line: n, handle: line, text: line.text, markerText: marker && marker.text, | ||
|
r8053 | markerClass: marker && marker.style, lineClass: line.className, bgClass: line.bgClassName}; | ||
|
r4504 | } | ||
function stringWidth(str) { | ||||
measure.innerHTML = "<pre><span>x</span></pre>"; | ||||
measure.firstChild.firstChild.firstChild.nodeValue = str; | ||||
return measure.firstChild.firstChild.offsetWidth || 10; | ||||
} | ||||
// These are used to go from pixel positions to character | ||||
// positions, taking varying character widths into account. | ||||
function charFromX(line, x) { | ||||
if (x <= 0) return 0; | ||||
|
r5941 | var lineObj = getLine(line), text = lineObj.text; | ||
|
r4504 | function getX(len) { | ||
|
r8053 | return measureLine(lineObj, len).left; | ||
|
r4504 | } | ||
var from = 0, fromX = 0, to = text.length, toX; | ||||
// Guess a suitable upper bound for our search. | ||||
|
r5941 | var estimated = Math.min(to, Math.ceil(x / charWidth())); | ||
|
r4504 | for (;;) { | ||
var estX = getX(estimated); | ||||
if (estX <= x && estimated < to) estimated = Math.min(to, Math.ceil(estimated * 1.2)); | ||||
else {toX = estX; to = estimated; break;} | ||||
} | ||||
if (x > toX) return to; | ||||
// Try to guess a suitable lower bound as well. | ||||
estimated = Math.floor(to * 0.8); estX = getX(estimated); | ||||
if (estX < x) {from = estimated; fromX = estX;} | ||||
// Do a binary search between these bounds. | ||||
for (;;) { | ||||
if (to - from <= 1) return (toX - x > x - fromX) ? from : to; | ||||
var middle = Math.ceil((from + to) / 2), middleX = getX(middle); | ||||
if (middleX > x) {to = middle; toX = middleX;} | ||||
else {from = middle; fromX = middleX;} | ||||
} | ||||
} | ||||
|
r8053 | var tempId = "CodeMirror-temp-" + Math.floor(Math.random() * 0xffffff).toString(16); | ||
|
r5941 | function measureLine(line, ch) { | ||
|
r5970 | if (ch == 0) return {top: 0, left: 0}; | ||
|
r8053 | var wbr = options.lineWrapping && ch < line.text.length && | ||
spanAffectsWrapping.test(line.text.slice(ch - 1, ch + 1)); | ||||
measure.innerHTML = "<pre>" + line.getHTML(makeTab, ch, tempId, wbr) + "</pre>"; | ||||
var elt = document.getElementById(tempId); | ||||
|
r5941 | var top = elt.offsetTop, left = elt.offsetLeft; | ||
// Older IEs report zero offsets for spans directly after a wrap | ||||
|
r5970 | if (ie && top == 0 && left == 0) { | ||
|
r5941 | var backup = document.createElement("span"); | ||
backup.innerHTML = "x"; | ||||
elt.parentNode.insertBefore(backup, elt.nextSibling); | ||||
top = backup.offsetTop; | ||||
} | ||||
return {top: top, left: left}; | ||||
} | ||||
|
r4504 | function localCoords(pos, inLineWrap) { | ||
|
r5941 | var x, lh = textHeight(), y = lh * (heightAtLine(doc, pos.line) - (inLineWrap ? displayOffset : 0)); | ||
if (pos.ch == 0) x = 0; | ||||
else { | ||||
var sp = measureLine(getLine(pos.line), pos.ch); | ||||
x = sp.left; | ||||
if (options.lineWrapping) y += Math.max(0, sp.top); | ||||
} | ||||
return {x: x, y: y, yBot: y + lh}; | ||||
} | ||||
// Coords must be lineSpace-local | ||||
function coordsChar(x, y) { | ||||
|
r8169 | if (y < 0) return {line: 0, ch: 0}; | ||
|
r5941 | var th = textHeight(), cw = charWidth(), heightPos = displayOffset + Math.floor(y / th); | ||
var lineNo = lineAtHeight(doc, heightPos); | ||||
if (lineNo >= doc.size) return {line: doc.size - 1, ch: getLine(doc.size - 1).text.length}; | ||||
var lineObj = getLine(lineNo), text = lineObj.text; | ||||
var tw = options.lineWrapping, innerOff = tw ? heightPos - heightAtLine(doc, lineNo) : 0; | ||||
if (x <= 0 && innerOff == 0) return {line: lineNo, ch: 0}; | ||||
function getX(len) { | ||||
var sp = measureLine(lineObj, len); | ||||
if (tw) { | ||||
var off = Math.round(sp.top / th); | ||||
return Math.max(0, sp.left + (off - innerOff) * scroller.clientWidth); | ||||
} | ||||
return sp.left; | ||||
} | ||||
var from = 0, fromX = 0, to = text.length, toX; | ||||
// Guess a suitable upper bound for our search. | ||||
var estimated = Math.min(to, Math.ceil((x + innerOff * scroller.clientWidth * .9) / cw)); | ||||
for (;;) { | ||||
var estX = getX(estimated); | ||||
if (estX <= x && estimated < to) estimated = Math.min(to, Math.ceil(estimated * 1.2)); | ||||
else {toX = estX; to = estimated; break;} | ||||
} | ||||
if (x > toX) return {line: lineNo, ch: to}; | ||||
// Try to guess a suitable lower bound as well. | ||||
estimated = Math.floor(to * 0.8); estX = getX(estimated); | ||||
if (estX < x) {from = estimated; fromX = estX;} | ||||
// Do a binary search between these bounds. | ||||
for (;;) { | ||||
if (to - from <= 1) return {line: lineNo, ch: (toX - x > x - fromX) ? from : to}; | ||||
var middle = Math.ceil((from + to) / 2), middleX = getX(middle); | ||||
if (middleX > x) {to = middle; toX = middleX;} | ||||
else {from = middle; fromX = middleX;} | ||||
} | ||||
|
r4504 | } | ||
function pageCoords(pos) { | ||||
var local = localCoords(pos, true), off = eltOffset(lineSpace); | ||||
return {x: off.left + local.x, y: off.top + local.y, yBot: off.top + local.yBot}; | ||||
} | ||||
|
r5941 | var cachedHeight, cachedHeightFor, measureText; | ||
function textHeight() { | ||||
if (measureText == null) { | ||||
measureText = "<pre>"; | ||||
for (var i = 0; i < 49; ++i) measureText += "x<br/>"; | ||||
measureText += "x</pre>"; | ||||
} | ||||
var offsetHeight = lineDiv.clientHeight; | ||||
if (offsetHeight == cachedHeightFor) return cachedHeight; | ||||
cachedHeightFor = offsetHeight; | ||||
measure.innerHTML = measureText; | ||||
cachedHeight = measure.firstChild.offsetHeight / 50 || 1; | ||||
measure.innerHTML = ""; | ||||
return cachedHeight; | ||||
} | ||||
var cachedWidth, cachedWidthFor = 0; | ||||
function charWidth() { | ||||
if (scroller.clientWidth == cachedWidthFor) return cachedWidth; | ||||
cachedWidthFor = scroller.clientWidth; | ||||
return (cachedWidth = stringWidth("x")); | ||||
|
r4504 | } | ||
function paddingTop() {return lineSpace.offsetTop;} | ||||
function paddingLeft() {return lineSpace.offsetLeft;} | ||||
function posFromMouse(e, liberal) { | ||||
var offW = eltOffset(scroller, true), x, y; | ||||
// Fails unpredictably on IE[67] when mouse is dragged around quickly. | ||||
try { x = e.clientX; y = e.clientY; } catch (e) { return null; } | ||||
// This is a mess of a heuristic to try and determine whether a | ||||
// scroll-bar was clicked or not, and to return null if one was | ||||
// (and !liberal). | ||||
if (!liberal && (x - offW.left > scroller.clientWidth || y - offW.top > scroller.clientHeight)) | ||||
return null; | ||||
var offL = eltOffset(lineSpace, true); | ||||
|
r5941 | return coordsChar(x - offL.left, y - offL.top); | ||
|
r4504 | } | ||
function onContextMenu(e) { | ||||
|
r8053 | var pos = posFromMouse(e), scrollPos = scrollbar.scrollTop; | ||
if (!pos || opera) return; // Opera is difficult. | ||||
|
r4504 | if (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to)) | ||
operation(setCursor)(pos.line, pos.ch); | ||||
var oldCSS = input.style.cssText; | ||||
inputDiv.style.position = "absolute"; | ||||
|
r4933 | input.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) + | ||
"px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: white; " + | ||||
|
r4504 | "border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"; | ||
leaveInputAlone = true; | ||||
var val = input.value = getSelection(); | ||||
focusInput(); | ||||
|
r6058 | selectInput(input); | ||
|
r4504 | function rehide() { | ||
var newVal = splitLines(input.value).join("\n"); | ||||
|
r8053 | if (newVal != val && !options.readOnly) operation(replaceSelection)(newVal, "end"); | ||
|
r4504 | inputDiv.style.position = "relative"; | ||
input.style.cssText = oldCSS; | ||||
|
r8053 | if (ie_lt9) scrollbar.scrollTop = scrollPos; | ||
|
r4504 | leaveInputAlone = false; | ||
|
r5941 | resetInput(true); | ||
|
r4504 | slowPoll(); | ||
} | ||||
|
r4934 | |||
|
r4504 | if (gecko) { | ||
e_stop(e); | ||||
var mouseup = connect(window, "mouseup", function() { | ||||
mouseup(); | ||||
setTimeout(rehide, 20); | ||||
}, true); | ||||
|
r8053 | } else { | ||
|
r4504 | setTimeout(rehide, 50); | ||
} | ||||
} | ||||
// Cursor-blinking | ||||
function restartBlink() { | ||||
clearInterval(blinker); | ||||
var on = true; | ||||
cursor.style.visibility = ""; | ||||
blinker = setInterval(function() { | ||||
cursor.style.visibility = (on = !on) ? "" : "hidden"; | ||||
}, 650); | ||||
} | ||||
var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"}; | ||||
function matchBrackets(autoclear) { | ||||
|
r5941 | var head = sel.inverted ? sel.from : sel.to, line = getLine(head.line), pos = head.ch - 1; | ||
|
r4504 | var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)]; | ||
if (!match) return; | ||||
var ch = match.charAt(0), forward = match.charAt(1) == ">", d = forward ? 1 : -1, st = line.styles; | ||||
for (var off = pos + 1, i = 0, e = st.length; i < e; i+=2) | ||||
if ((off -= st[i].length) <= 0) {var style = st[i+1]; break;} | ||||
var stack = [line.text.charAt(pos)], re = /[(){}[\]]/; | ||||
function scan(line, from, to) { | ||||
if (!line.text) return; | ||||
var st = line.styles, pos = forward ? 0 : line.text.length - 1, cur; | ||||
for (var i = forward ? 0 : st.length - 2, e = forward ? st.length : -2; i != e; i += 2*d) { | ||||
var text = st[i]; | ||||
|
r8053 | if (st[i+1] != style) {pos += d * text.length; continue;} | ||
|
r4504 | for (var j = forward ? 0 : text.length - 1, te = forward ? text.length : -1; j != te; j += d, pos+=d) { | ||
if (pos >= from && pos < to && re.test(cur = text.charAt(j))) { | ||||
var match = matching[cur]; | ||||
if (match.charAt(1) == ">" == forward) stack.push(cur); | ||||
else if (stack.pop() != match.charAt(0)) return {pos: pos, match: false}; | ||||
else if (!stack.length) return {pos: pos, match: true}; | ||||
} | ||||
} | ||||
} | ||||
} | ||||
|
r5941 | for (var i = head.line, e = forward ? Math.min(i + 100, doc.size) : Math.max(-1, i - 100); i != e; i+=d) { | ||
var line = getLine(i), first = i == head.line; | ||||
|
r4504 | var found = scan(line, first && forward ? pos + 1 : 0, first && !forward ? pos : line.text.length); | ||
if (found) break; | ||||
} | ||||
if (!found) found = {pos: null, match: false}; | ||||
var style = found.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket"; | ||||
var one = markText({line: head.line, ch: pos}, {line: head.line, ch: pos+1}, style), | ||||
|
r5941 | two = found.pos != null && markText({line: i, ch: found.pos}, {line: i, ch: found.pos + 1}, style); | ||
var clear = operation(function(){one.clear(); two && two.clear();}); | ||||
|
r4504 | if (autoclear) setTimeout(clear, 800); | ||
else bracketHighlighted = clear; | ||||
} | ||||
// Finds the line to start with when starting a parse. Tries to | ||||
// find a line with a stateAfter, so that it can start with a | ||||
// valid state. If that fails, it returns the line with the | ||||
// smallest indentation, which tends to need the least context to | ||||
// parse correctly. | ||||
function findStartLine(n) { | ||||
var minindent, minline; | ||||
for (var search = n, lim = n - 40; search > lim; --search) { | ||||
if (search == 0) return 0; | ||||
|
r5941 | var line = getLine(search-1); | ||
|
r4504 | if (line.stateAfter) return search; | ||
|
r5941 | var indented = line.indentation(options.tabSize); | ||
|
r4504 | if (minline == null || minindent > indented) { | ||
|
r4933 | minline = search - 1; | ||
|
r4504 | minindent = indented; | ||
} | ||||
} | ||||
return minline; | ||||
} | ||||
function getStateBefore(n) { | ||||
|
r5941 | var start = findStartLine(n), state = start && getLine(start-1).stateAfter; | ||
|
r4504 | if (!state) state = startState(mode); | ||
else state = copyState(mode, state); | ||||
|
r5941 | doc.iter(start, n, function(line) { | ||
line.highlight(mode, state, options.tabSize); | ||||
|
r4504 | line.stateAfter = copyState(mode, state); | ||
|
r5941 | }); | ||
if (start < n) changes.push({from: start, to: n}); | ||||
if (n < doc.size && !getLine(n).stateAfter) work.push(n); | ||||
|
r4504 | return state; | ||
} | ||||
function highlightLines(start, end) { | ||||
var state = getStateBefore(start); | ||||
|
r5941 | doc.iter(start, end, function(line) { | ||
line.highlight(mode, state, options.tabSize); | ||||
|
r4504 | line.stateAfter = copyState(mode, state); | ||
|
r5941 | }); | ||
|
r4504 | } | ||
function highlightWorker() { | ||||
var end = +new Date + options.workTime; | ||||
var foundWork = work.length; | ||||
while (work.length) { | ||||
|
r5941 | if (!getLine(showingFrom).stateAfter) var task = showingFrom; | ||
|
r4504 | else var task = work.pop(); | ||
|
r5941 | if (task >= doc.size) continue; | ||
var start = findStartLine(task), state = start && getLine(start-1).stateAfter; | ||||
|
r4504 | if (state) state = copyState(mode, state); | ||
else state = startState(mode); | ||||
|
r5941 | var unchanged = 0, compare = mode.compareStates, realChange = false, | ||
i = start, bail = false; | ||||
doc.iter(i, doc.size, function(line) { | ||||
var hadState = line.stateAfter; | ||||
|
r4504 | if (+new Date > end) { | ||
work.push(i); | ||||
startWorker(options.workDelay); | ||||
|
r4933 | if (realChange) changes.push({from: task, to: i + 1}); | ||
|
r5941 | return (bail = true); | ||
|
r4504 | } | ||
|
r5941 | var changed = line.highlight(mode, state, options.tabSize); | ||
|
r4933 | if (changed) realChange = true; | ||
|
r4504 | line.stateAfter = copyState(mode, state); | ||
|
r8053 | var done = null; | ||
|
r4504 | if (compare) { | ||
|
r8053 | var same = hadState && compare(hadState, state); | ||
if (same != Pass) done = !!same; | ||||
} | ||||
if (done == null) { | ||||
|
r4933 | if (changed !== false || !hadState) unchanged = 0; | ||
|
r5941 | else if (++unchanged > 3 && (!mode.indent || mode.indent(hadState, "") == mode.indent(state, ""))) | ||
|
r8053 | done = true; | ||
|
r4504 | } | ||
|
r8053 | if (done) return true; | ||
|
r5941 | ++i; | ||
}); | ||||
if (bail) return; | ||||
|
r4933 | if (realChange) changes.push({from: task, to: i + 1}); | ||
|
r4504 | } | ||
if (foundWork && options.onHighlightComplete) | ||||
options.onHighlightComplete(instance); | ||||
} | ||||
function startWorker(time) { | ||||
if (!work.length) return; | ||||
highlight.set(time, operation(highlightWorker)); | ||||
} | ||||
// Operations are used to wrap changes in such a way that each | ||||
// change won't have to update the cursor and display (which would | ||||
// be awkward, slow, and error-prone), but instead updates are | ||||
// batched and then all combined and executed at once. | ||||
function startOperation() { | ||||
|
r5941 | updateInput = userSelChange = textChanged = null; | ||
changes = []; selectionChanged = false; callbacks = []; | ||||
|
r4504 | } | ||
function endOperation() { | ||||
|
r8053 | if (updateMaxLine) computeMaxLength(); | ||
if (maxLineChanged && !options.lineWrapping) { | ||||
var cursorWidth = widthForcer.offsetWidth, left = stringWidth(maxLine); | ||||
widthForcer.style.left = left + "px"; | ||||
lineSpace.style.minWidth = (left + cursorWidth) + "px"; | ||||
maxLineChanged = false; | ||||
} | ||||
var newScrollPos, updated; | ||||
if (selectionChanged) { | ||||
var coords = calculateCursorCoords(); | ||||
newScrollPos = calculateScrollPos(coords.x, coords.y, coords.x, coords.yBot); | ||||
} | ||||
if (changes.length) updated = updateDisplay(changes, true, (newScrollPos ? newScrollPos.scrollTop : null)); | ||||
|
r4933 | else { | ||
|
r5970 | if (selectionChanged) updateSelection(); | ||
|
r4933 | if (gutterDirty) updateGutter(); | ||
} | ||||
|
r8053 | if (newScrollPos) scrollCursorIntoView(); | ||
|
r4933 | if (selectionChanged) {scrollEditorIntoView(); restartBlink();} | ||
|
r4504 | |||
if (focused && !leaveInputAlone && | ||||
(updateInput === true || (updateInput !== false && selectionChanged))) | ||||
|
r5941 | resetInput(userSelChange); | ||
|
r4504 | |||
if (selectionChanged && options.matchBrackets) | ||||
setTimeout(operation(function() { | ||||
if (bracketHighlighted) {bracketHighlighted(); bracketHighlighted = null;} | ||||
|
r5941 | if (posEq(sel.from, sel.to)) matchBrackets(false); | ||
|
r4504 | }), 20); | ||
|
r8053 | var sc = selectionChanged, cbs = callbacks; // these can be reset by callbacks | ||
if (textChanged && options.onChange && instance) | ||||
options.onChange(instance, textChanged); | ||||
if (sc && options.onCursorActivity) | ||||
|
r4504 | options.onCursorActivity(instance); | ||
|
r5941 | for (var i = 0; i < cbs.length; ++i) cbs[i](instance); | ||
if (updated && options.onUpdate) options.onUpdate(instance); | ||||
|
r4504 | } | ||
var nestedOperation = 0; | ||||
function operation(f) { | ||||
return function() { | ||||
if (!nestedOperation++) startOperation(); | ||||
try {var result = f.apply(this, arguments);} | ||||
finally {if (!--nestedOperation) endOperation();} | ||||
return result; | ||||
}; | ||||
} | ||||
|
r8053 | function compoundChange(f) { | ||
history.startCompound(); | ||||
try { return f(); } finally { history.endCompound(); } | ||||
} | ||||
|
r4504 | for (var ext in extensions) | ||
if (extensions.propertyIsEnumerable(ext) && | ||||
!instance.propertyIsEnumerable(ext)) | ||||
instance[ext] = extensions[ext]; | ||||
return instance; | ||||
} // (end of function CodeMirror) | ||||
// The default configuration options. | ||||
CodeMirror.defaults = { | ||||
value: "", | ||||
mode: null, | ||||
theme: "default", | ||||
indentUnit: 2, | ||||
indentWithTabs: false, | ||||
|
r5970 | smartIndent: true, | ||
|
r5941 | tabSize: 4, | ||
keyMap: "default", | ||||
extraKeys: null, | ||||
|
r4504 | electricChars: true, | ||
|
r8053 | autoClearEmptyLines: false, | ||
|
r4504 | onKeyEvent: null, | ||
|
r8053 | onDragEvent: null, | ||
|
r5941 | lineWrapping: false, | ||
|
r4504 | lineNumbers: false, | ||
gutter: false, | ||||
|
r4933 | fixedGutter: false, | ||
|
r4504 | firstLineNumber: 1, | ||
readOnly: false, | ||||
|
r8053 | dragDrop: true, | ||
|
r4504 | onChange: null, | ||
onCursorActivity: null, | ||||
onGutterClick: null, | ||||
onHighlightComplete: null, | ||||
|
r5941 | onUpdate: null, | ||
|
r4504 | onFocus: null, onBlur: null, onScroll: null, | ||
matchBrackets: false, | ||||
workTime: 100, | ||||
workDelay: 200, | ||||
|
r5941 | pollInterval: 100, | ||
|
r4504 | undoDepth: 40, | ||
tabindex: null, | ||||
|
r8053 | autofocus: null, | ||
lineNumberFormatter: function(integer) { return integer; } | ||||
|
r4504 | }; | ||
|
r5970 | var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent); | ||
var mac = ios || /Mac/.test(navigator.platform); | ||||
|
r5941 | var win = /Win/.test(navigator.platform); | ||
|
r4504 | // Known modes, by name and by MIME | ||
|
r8053 | var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {}; | ||
|
r4504 | CodeMirror.defineMode = function(name, mode) { | ||
if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name; | ||||
|
r8053 | if (arguments.length > 2) { | ||
mode.dependencies = []; | ||||
for (var i = 2; i < arguments.length; ++i) mode.dependencies.push(arguments[i]); | ||||
} | ||||
|
r4504 | modes[name] = mode; | ||
}; | ||||
CodeMirror.defineMIME = function(mime, spec) { | ||||
mimeModes[mime] = spec; | ||||
}; | ||||
|
r8053 | CodeMirror.resolveMode = function(spec) { | ||
|
r4504 | if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) | ||
spec = mimeModes[spec]; | ||||
|
r8053 | else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) | ||
return CodeMirror.resolveMode("application/xml"); | ||||
if (typeof spec == "string") return {name: spec}; | ||||
else return spec || {name: "null"}; | ||||
}; | ||||
CodeMirror.getMode = function(options, spec) { | ||||
var spec = CodeMirror.resolveMode(spec); | ||||
var mfactory = modes[spec.name]; | ||||
if (!mfactory) return CodeMirror.getMode(options, "text/plain"); | ||||
return mfactory(options, spec); | ||||
|
r4504 | }; | ||
CodeMirror.listModes = function() { | ||||
var list = []; | ||||
for (var m in modes) | ||||
if (modes.propertyIsEnumerable(m)) list.push(m); | ||||
return list; | ||||
}; | ||||
CodeMirror.listMIMEs = function() { | ||||
var list = []; | ||||
for (var m in mimeModes) | ||||
|
r4933 | if (mimeModes.propertyIsEnumerable(m)) list.push({mime: m, mode: mimeModes[m]}); | ||
|
r4504 | return list; | ||
}; | ||||
|
r5941 | var extensions = CodeMirror.extensions = {}; | ||
|
r4504 | CodeMirror.defineExtension = function(name, func) { | ||
extensions[name] = func; | ||||
}; | ||||
|
r5941 | var commands = CodeMirror.commands = { | ||
selectAll: function(cm) {cm.setSelection({line: 0, ch: 0}, {line: cm.lineCount() - 1});}, | ||||
killLine: function(cm) { | ||||
var from = cm.getCursor(true), to = cm.getCursor(false), sel = !posEq(from, to); | ||||
if (!sel && cm.getLine(from.line).length == from.ch) cm.replaceRange("", from, {line: from.line + 1, ch: 0}); | ||||
else cm.replaceRange("", from, sel ? to : {line: from.line}); | ||||
}, | ||||
deleteLine: function(cm) {var l = cm.getCursor().line; cm.replaceRange("", {line: l, ch: 0}, {line: l});}, | ||||
undo: function(cm) {cm.undo();}, | ||||
redo: function(cm) {cm.redo();}, | ||||
goDocStart: function(cm) {cm.setCursor(0, 0, true);}, | ||||
goDocEnd: function(cm) {cm.setSelection({line: cm.lineCount() - 1}, null, true);}, | ||||
goLineStart: function(cm) {cm.setCursor(cm.getCursor().line, 0, true);}, | ||||
goLineStartSmart: function(cm) { | ||||
var cur = cm.getCursor(); | ||||
var text = cm.getLine(cur.line), firstNonWS = Math.max(0, text.search(/\S/)); | ||||
cm.setCursor(cur.line, cur.ch <= firstNonWS && cur.ch ? 0 : firstNonWS, true); | ||||
}, | ||||
goLineEnd: function(cm) {cm.setSelection({line: cm.getCursor().line}, null, true);}, | ||||
goLineUp: function(cm) {cm.moveV(-1, "line");}, | ||||
goLineDown: function(cm) {cm.moveV(1, "line");}, | ||||
goPageUp: function(cm) {cm.moveV(-1, "page");}, | ||||
goPageDown: function(cm) {cm.moveV(1, "page");}, | ||||
goCharLeft: function(cm) {cm.moveH(-1, "char");}, | ||||
goCharRight: function(cm) {cm.moveH(1, "char");}, | ||||
goColumnLeft: function(cm) {cm.moveH(-1, "column");}, | ||||
goColumnRight: function(cm) {cm.moveH(1, "column");}, | ||||
goWordLeft: function(cm) {cm.moveH(-1, "word");}, | ||||
goWordRight: function(cm) {cm.moveH(1, "word");}, | ||||
delCharLeft: function(cm) {cm.deleteH(-1, "char");}, | ||||
delCharRight: function(cm) {cm.deleteH(1, "char");}, | ||||
delWordLeft: function(cm) {cm.deleteH(-1, "word");}, | ||||
delWordRight: function(cm) {cm.deleteH(1, "word");}, | ||||
indentAuto: function(cm) {cm.indentSelection("smart");}, | ||||
indentMore: function(cm) {cm.indentSelection("add");}, | ||||
indentLess: function(cm) {cm.indentSelection("subtract");}, | ||||
insertTab: function(cm) {cm.replaceSelection("\t", "end");}, | ||||
|
r8053 | defaultTab: function(cm) { | ||
if (cm.somethingSelected()) cm.indentSelection("add"); | ||||
else cm.replaceSelection("\t", "end"); | ||||
}, | ||||
|
r5941 | transposeChars: function(cm) { | ||
var cur = cm.getCursor(), line = cm.getLine(cur.line); | ||||
if (cur.ch > 0 && cur.ch < line.length - 1) | ||||
cm.replaceRange(line.charAt(cur.ch) + line.charAt(cur.ch - 1), | ||||
{line: cur.line, ch: cur.ch - 1}, {line: cur.line, ch: cur.ch + 1}); | ||||
}, | ||||
newlineAndIndent: function(cm) { | ||||
cm.replaceSelection("\n", "end"); | ||||
cm.indentLine(cm.getCursor().line); | ||||
}, | ||||
toggleOverwrite: function(cm) {cm.toggleOverwrite();} | ||||
}; | ||||
var keyMap = CodeMirror.keyMap = {}; | ||||
keyMap.basic = { | ||||
"Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown", | ||||
"End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown", | ||||
|
r8053 | "Delete": "delCharRight", "Backspace": "delCharLeft", "Tab": "defaultTab", "Shift-Tab": "indentAuto", | ||
|
r5941 | "Enter": "newlineAndIndent", "Insert": "toggleOverwrite" | ||
}; | ||||
// Note that the save and find-related commands aren't defined by | ||||
// default. Unknown commands are simply ignored. | ||||
keyMap.pcDefault = { | ||||
"Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo", | ||||
"Ctrl-Home": "goDocStart", "Alt-Up": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Down": "goDocEnd", | ||||
"Ctrl-Left": "goWordLeft", "Ctrl-Right": "goWordRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd", | ||||
"Ctrl-Backspace": "delWordLeft", "Ctrl-Delete": "delWordRight", "Ctrl-S": "save", "Ctrl-F": "find", | ||||
"Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll", | ||||
|
r8053 | "Ctrl-[": "indentLess", "Ctrl-]": "indentMore", | ||
|
r5941 | fallthrough: "basic" | ||
}; | ||||
keyMap.macDefault = { | ||||
"Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo", | ||||
"Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goWordLeft", | ||||
"Alt-Right": "goWordRight", "Cmd-Left": "goLineStart", "Cmd-Right": "goLineEnd", "Alt-Backspace": "delWordLeft", | ||||
"Ctrl-Alt-Backspace": "delWordRight", "Alt-Delete": "delWordRight", "Cmd-S": "save", "Cmd-F": "find", | ||||
"Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll", | ||||
|
r8053 | "Cmd-[": "indentLess", "Cmd-]": "indentMore", | ||
|
r5941 | fallthrough: ["basic", "emacsy"] | ||
}; | ||||
keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault; | ||||
keyMap.emacsy = { | ||||
"Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown", | ||||
"Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd", | ||||
"Ctrl-V": "goPageUp", "Shift-Ctrl-V": "goPageDown", "Ctrl-D": "delCharRight", "Ctrl-H": "delCharLeft", | ||||
"Alt-D": "delWordRight", "Alt-Backspace": "delWordLeft", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars" | ||||
}; | ||||
|
r8053 | function getKeyMap(val) { | ||
if (typeof val == "string") return keyMap[val]; | ||||
else return val; | ||||
} | ||||
function lookupKey(name, extraMap, map, handle, stop) { | ||||
function lookup(map) { | ||||
map = getKeyMap(map); | ||||
|
r5941 | var found = map[name]; | ||
|
r8053 | if (found != null && handle(found)) return true; | ||
if (map.nofallthrough) { | ||||
if (stop) stop(); | ||||
return true; | ||||
|
r5941 | } | ||
|
r8053 | var fallthrough = map.fallthrough; | ||
if (fallthrough == null) return false; | ||||
if (Object.prototype.toString.call(fallthrough) != "[object Array]") | ||||
return lookup(fallthrough); | ||||
for (var i = 0, e = fallthrough.length; i < e; ++i) { | ||||
if (lookup(fallthrough[i])) return true; | ||||
} | ||||
return false; | ||||
|
r5941 | } | ||
|
r8053 | if (extraMap && lookup(extraMap)) return true; | ||
return lookup(map); | ||||
|
r5941 | } | ||
function isModifierKey(event) { | ||||
|
r5970 | var name = keyNames[e_prop(event, "keyCode")]; | ||
|
r5941 | return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"; | ||
} | ||||
|
r4504 | CodeMirror.fromTextArea = function(textarea, options) { | ||
if (!options) options = {}; | ||||
options.value = textarea.value; | ||||
if (!options.tabindex && textarea.tabindex) | ||||
options.tabindex = textarea.tabindex; | ||||
|
r8053 | if (options.autofocus == null && textarea.getAttribute("autofocus") != null) | ||
options.autofocus = true; | ||||
|
r4504 | |||
function save() {textarea.value = instance.getValue();} | ||||
if (textarea.form) { | ||||
// Deplorable hack to make the submit method do the right thing. | ||||
var rmSubmit = connect(textarea.form, "submit", save, true); | ||||
if (typeof textarea.form.submit == "function") { | ||||
var realSubmit = textarea.form.submit; | ||||
function wrappedSubmit() { | ||||
save(); | ||||
textarea.form.submit = realSubmit; | ||||
textarea.form.submit(); | ||||
textarea.form.submit = wrappedSubmit; | ||||
} | ||||
textarea.form.submit = wrappedSubmit; | ||||
} | ||||
} | ||||
textarea.style.display = "none"; | ||||
var instance = CodeMirror(function(node) { | ||||
textarea.parentNode.insertBefore(node, textarea.nextSibling); | ||||
}, options); | ||||
instance.save = save; | ||||
|
r5941 | instance.getTextArea = function() { return textarea; }; | ||
|
r4504 | instance.toTextArea = function() { | ||
save(); | ||||
textarea.parentNode.removeChild(instance.getWrapperElement()); | ||||
textarea.style.display = ""; | ||||
if (textarea.form) { | ||||
rmSubmit(); | ||||
if (typeof textarea.form.submit == "function") | ||||
textarea.form.submit = realSubmit; | ||||
} | ||||
}; | ||||
return instance; | ||||
}; | ||||
// Utility functions for working with state. Exported because modes | ||||
// sometimes need to do this. | ||||
function copyState(mode, state) { | ||||
if (state === true) return state; | ||||
if (mode.copyState) return mode.copyState(state); | ||||
var nstate = {}; | ||||
for (var n in state) { | ||||
var val = state[n]; | ||||
if (val instanceof Array) val = val.concat([]); | ||||
nstate[n] = val; | ||||
} | ||||
return nstate; | ||||
} | ||||
|
r5941 | CodeMirror.copyState = copyState; | ||
|
r4504 | function startState(mode, a1, a2) { | ||
return mode.startState ? mode.startState(a1, a2) : true; | ||||
} | ||||
|
r5941 | CodeMirror.startState = startState; | ||
|
r4504 | |||
// The character stream used by a mode's parser. | ||||
|
r5941 | function StringStream(string, tabSize) { | ||
|
r4504 | this.pos = this.start = 0; | ||
this.string = string; | ||||
|
r5941 | this.tabSize = tabSize || 8; | ||
|
r4504 | } | ||
StringStream.prototype = { | ||||
eol: function() {return this.pos >= this.string.length;}, | ||||
sol: function() {return this.pos == 0;}, | ||||
peek: function() {return this.string.charAt(this.pos);}, | ||||
next: function() { | ||||
if (this.pos < this.string.length) | ||||
return this.string.charAt(this.pos++); | ||||
}, | ||||
eat: function(match) { | ||||
var ch = this.string.charAt(this.pos); | ||||
if (typeof match == "string") var ok = ch == match; | ||||
else var ok = ch && (match.test ? match.test(ch) : match(ch)); | ||||
if (ok) {++this.pos; return ch;} | ||||
}, | ||||
eatWhile: function(match) { | ||||
|
r4933 | var start = this.pos; | ||
|
r4504 | while (this.eat(match)){} | ||
return this.pos > start; | ||||
}, | ||||
eatSpace: function() { | ||||
var start = this.pos; | ||||
while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos; | ||||
return this.pos > start; | ||||
}, | ||||
skipToEnd: function() {this.pos = this.string.length;}, | ||||
skipTo: function(ch) { | ||||
var found = this.string.indexOf(ch, this.pos); | ||||
if (found > -1) {this.pos = found; return true;} | ||||
}, | ||||
backUp: function(n) {this.pos -= n;}, | ||||
|
r5941 | column: function() {return countColumn(this.string, this.start, this.tabSize);}, | ||
indentation: function() {return countColumn(this.string, null, this.tabSize);}, | ||||
|
r4504 | match: function(pattern, consume, caseInsensitive) { | ||
if (typeof pattern == "string") { | ||||
function cased(str) {return caseInsensitive ? str.toLowerCase() : str;} | ||||
if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) { | ||||
if (consume !== false) this.pos += pattern.length; | ||||
return true; | ||||
} | ||||
|
r8053 | } else { | ||
|
r4504 | var match = this.string.slice(this.pos).match(pattern); | ||
if (match && consume !== false) this.pos += match[0].length; | ||||
return match; | ||||
} | ||||
}, | ||||
current: function(){return this.string.slice(this.start, this.pos);} | ||||
}; | ||||
CodeMirror.StringStream = StringStream; | ||||
|
r8053 | function MarkedText(from, to, className, marker) { | ||
this.from = from; this.to = to; this.style = className; this.marker = marker; | ||||
|
r5941 | } | ||
MarkedText.prototype = { | ||||
|
r8053 | attach: function(line) { this.marker.set.push(line); }, | ||
|
r5941 | detach: function(line) { | ||
|
r8053 | var ix = indexOf(this.marker.set, line); | ||
if (ix > -1) this.marker.set.splice(ix, 1); | ||||
|
r5941 | }, | ||
split: function(pos, lenBefore) { | ||||
if (this.to <= pos && this.to != null) return null; | ||||
var from = this.from < pos || this.from == null ? null : this.from - pos + lenBefore; | ||||
var to = this.to == null ? null : this.to - pos + lenBefore; | ||||
|
r8053 | return new MarkedText(from, to, this.style, this.marker); | ||
|
r5941 | }, | ||
|
r8053 | dup: function() { return new MarkedText(null, null, this.style, this.marker); }, | ||
|
r5941 | clipTo: function(fromOpen, from, toOpen, to, diff) { | ||
if (fromOpen && to > this.from && (to < this.to || this.to == null)) | ||||
this.from = null; | ||||
|
r8053 | else if (this.from != null && this.from >= from) | ||
this.from = Math.max(to, this.from) + diff; | ||||
|
r5941 | if (toOpen && (from < this.to || this.to == null) && (from > this.from || this.from == null)) | ||
this.to = null; | ||||
|
r8053 | else if (this.to != null && this.to > from) | ||
this.to = to < this.to ? this.to + diff : from; | ||||
|
r5941 | }, | ||
isDead: function() { return this.from != null && this.to != null && this.from >= this.to; }, | ||||
|
r8053 | sameSet: function(x) { return this.marker == x.marker; } | ||
|
r5941 | }; | ||
function Bookmark(pos) { | ||||
this.from = pos; this.to = pos; this.line = null; | ||||
} | ||||
Bookmark.prototype = { | ||||
attach: function(line) { this.line = line; }, | ||||
detach: function(line) { if (this.line == line) this.line = null; }, | ||||
split: function(pos, lenBefore) { | ||||
if (pos < this.from) { | ||||
this.from = this.to = (this.from - pos) + lenBefore; | ||||
return this; | ||||
} | ||||
}, | ||||
isDead: function() { return this.from > this.to; }, | ||||
clipTo: function(fromOpen, from, toOpen, to, diff) { | ||||
if ((fromOpen || from < this.from) && (toOpen || to > this.to)) { | ||||
this.from = 0; this.to = -1; | ||||
} else if (this.from > from) { | ||||
this.from = this.to = Math.max(to, this.from) + diff; | ||||
} | ||||
}, | ||||
sameSet: function(x) { return false; }, | ||||
find: function() { | ||||
if (!this.line || !this.line.parent) return null; | ||||
return {line: lineNo(this.line), ch: this.from}; | ||||
}, | ||||
clear: function() { | ||||
if (this.line) { | ||||
var found = indexOf(this.line.marked, this); | ||||
if (found != -1) this.line.marked.splice(found, 1); | ||||
this.line = null; | ||||
} | ||||
} | ||||
}; | ||||
|
r4504 | // Line objects. These hold state related to a line, including | ||
// highlighting info (the styles array). | ||||
function Line(text, styles) { | ||||
this.styles = styles || [text, null]; | ||||
this.text = text; | ||||
|
r5941 | this.height = 1; | ||
|
r8053 | this.marked = this.gutterMarker = this.className = this.bgClassName = this.handlers = null; | ||
|
r5941 | this.stateAfter = this.parent = this.hidden = null; | ||
} | ||||
Line.inheritMarks = function(text, orig) { | ||||
var ln = new Line(text), mk = orig && orig.marked; | ||||
if (mk) { | ||||
for (var i = 0; i < mk.length; ++i) { | ||||
if (mk[i].to == null && mk[i].style) { | ||||
var newmk = ln.marked || (ln.marked = []), mark = mk[i]; | ||||
var nmark = mark.dup(); newmk.push(nmark); nmark.attach(ln); | ||||
} | ||||
} | ||||
} | ||||
return ln; | ||||
|
r4504 | } | ||
Line.prototype = { | ||||
// Replace a piece of a line, keeping the styles around it intact. | ||||
|
r5941 | replace: function(from, to_, text) { | ||
var st = [], mk = this.marked, to = to_ == null ? this.text.length : to_; | ||||
|
r4504 | copyStyles(0, from, this.styles, st); | ||
if (text) st.push(text, null); | ||||
copyStyles(to, this.text.length, this.styles, st); | ||||
this.styles = st; | ||||
this.text = this.text.slice(0, from) + text + this.text.slice(to); | ||||
this.stateAfter = null; | ||||
if (mk) { | ||||
|
r5941 | var diff = text.length - (to - from); | ||
|
r5970 | for (var i = 0; i < mk.length; ++i) { | ||
var mark = mk[i]; | ||||
|
r5941 | mark.clipTo(from == null, from || 0, to_ == null, to, diff); | ||
if (mark.isDead()) {mark.detach(this); mk.splice(i--, 1);} | ||||
|
r4504 | } | ||
} | ||||
}, | ||||
|
r5941 | // Split a part off a line, keeping styles and markers intact. | ||
|
r4504 | split: function(pos, textBefore) { | ||
|
r5941 | var st = [textBefore, null], mk = this.marked; | ||
|
r4504 | copyStyles(pos, this.text.length, this.styles, st); | ||
|
r5941 | var taken = new Line(textBefore + this.text.slice(pos), st); | ||
if (mk) { | ||||
for (var i = 0; i < mk.length; ++i) { | ||||
var mark = mk[i]; | ||||
var newmark = mark.split(pos, textBefore.length); | ||||
if (newmark) { | ||||
if (!taken.marked) taken.marked = []; | ||||
taken.marked.push(newmark); newmark.attach(taken); | ||||
|
r8053 | if (newmark == mark) mk.splice(i--, 1); | ||
|
r5941 | } | ||
} | ||||
} | ||||
return taken; | ||||
|
r4504 | }, | ||
|
r5941 | append: function(line) { | ||
var mylen = this.text.length, mk = line.marked, mymk = this.marked; | ||||
this.text += line.text; | ||||
copyStyles(0, line.text.length, line.styles, this.styles); | ||||
if (mymk) { | ||||
for (var i = 0; i < mymk.length; ++i) | ||||
if (mymk[i].to == null) mymk[i].to = mylen; | ||||
} | ||||
if (mk && mk.length) { | ||||
if (!mymk) this.marked = mymk = []; | ||||
outer: for (var i = 0; i < mk.length; ++i) { | ||||
var mark = mk[i]; | ||||
if (!mark.from) { | ||||
for (var j = 0; j < mymk.length; ++j) { | ||||
var mymark = mymk[j]; | ||||
if (mymark.to == mylen && mymark.sameSet(mark)) { | ||||
mymark.to = mark.to == null ? null : mark.to + mylen; | ||||
if (mymark.isDead()) { | ||||
mymark.detach(this); | ||||
mk.splice(i--, 1); | ||||
} | ||||
continue outer; | ||||
} | ||||
} | ||||
} | ||||
mymk.push(mark); | ||||
mark.attach(this); | ||||
mark.from += mylen; | ||||
if (mark.to != null) mark.to += mylen; | ||||
} | ||||
} | ||||
}, | ||||
fixMarkEnds: function(other) { | ||||
var mk = this.marked, omk = other.marked; | ||||
if (!mk) return; | ||||
|
r8053 | outer: for (var i = 0; i < mk.length; ++i) { | ||
|
r5941 | var mark = mk[i], close = mark.to == null; | ||
if (close && omk) { | ||||
|
r8053 | for (var j = 0; j < omk.length; ++j) { | ||
var om = omk[j]; | ||||
if (!om.sameSet(mark) || om.from != null) continue | ||||
if (mark.from == this.text.length && om.to == 0) { | ||||
omk.splice(j, 1); | ||||
mk.splice(i--, 1); | ||||
continue outer; | ||||
} else { | ||||
close = false; break; | ||||
} | ||||
} | ||||
|
r5941 | } | ||
if (close) mark.to = this.text.length; | ||||
} | ||||
|
r4504 | }, | ||
|
r5941 | fixMarkStarts: function() { | ||
|
r4504 | var mk = this.marked; | ||
if (!mk) return; | ||||
for (var i = 0; i < mk.length; ++i) | ||||
|
r5941 | if (mk[i].from == null) mk[i].from = 0; | ||
}, | ||||
addMark: function(mark) { | ||||
mark.attach(this); | ||||
if (this.marked == null) this.marked = []; | ||||
this.marked.push(mark); | ||||
this.marked.sort(function(a, b){return (a.from || 0) - (b.from || 0);}); | ||||
|
r4504 | }, | ||
// Run the given mode's parser over a line, update the styles | ||||
// array, which contains alternating fragments of text and CSS | ||||
// classes. | ||||
|
r5941 | highlight: function(mode, state, tabSize) { | ||
var stream = new StringStream(this.text, tabSize), st = this.styles, pos = 0; | ||||
|
r4504 | var changed = false, curWord = st[0], prevWord; | ||
if (this.text == "" && mode.blankLine) mode.blankLine(state); | ||||
while (!stream.eol()) { | ||||
var style = mode.token(stream, state); | ||||
var substr = this.text.slice(stream.start, stream.pos); | ||||
stream.start = stream.pos; | ||||
if (pos && st[pos-1] == style) | ||||
st[pos-2] += substr; | ||||
else if (substr) { | ||||
if (!changed && (st[pos+1] != style || (pos && st[pos-2] != prevWord))) changed = true; | ||||
st[pos++] = substr; st[pos++] = style; | ||||
prevWord = curWord; curWord = st[pos]; | ||||
} | ||||
// Give up when line is ridiculously long | ||||
if (stream.pos > 5000) { | ||||
st[pos++] = this.text.slice(stream.pos); st[pos++] = null; | ||||
break; | ||||
} | ||||
} | ||||
if (st.length != pos) {st.length = pos; changed = true;} | ||||
if (pos && st[pos-2] != prevWord) changed = true; | ||||
|
r4933 | // Short lines with simple highlights return null, and are | ||
// counted as changed by the driver because they are likely to | ||||
// highlight the same way in various contexts. | ||||
return changed || (st.length < 5 && this.text.length < 10 ? null : false); | ||||
|
r4504 | }, | ||
// Fetch the parser token for a given character. Useful for hacks | ||||
// that want to inspect the mode state (say, for completion). | ||||
getTokenAt: function(mode, state, ch) { | ||||
var txt = this.text, stream = new StringStream(txt); | ||||
while (stream.pos < ch && !stream.eol()) { | ||||
stream.start = stream.pos; | ||||
var style = mode.token(stream, state); | ||||
} | ||||
return {start: stream.start, | ||||
end: stream.pos, | ||||
string: stream.current(), | ||||
className: style || null, | ||||
state: state}; | ||||
}, | ||||
|
r5941 | indentation: function(tabSize) {return countColumn(this.text, null, tabSize);}, | ||
|
r4504 | // Produces an HTML fragment for the line, taking selection, | ||
// marking, and highlighting into account. | ||||
|
r8053 | getHTML: function(makeTab, wrapAt, wrapId, wrapWBR) { | ||
var html = [], first = true, col = 0; | ||||
function span_(text, style) { | ||||
|
r4504 | if (!text) return; | ||
|
r5941 | // Work around a bug where, in some compat modes, IE ignores leading spaces | ||
if (first && ie && text.charAt(0) == " ") text = "\u00a0" + text.slice(1); | ||||
first = false; | ||||
|
r8053 | if (text.indexOf("\t") == -1) { | ||
col += text.length; | ||||
var escaped = htmlEscape(text); | ||||
} else { | ||||
var escaped = ""; | ||||
for (var pos = 0;;) { | ||||
var idx = text.indexOf("\t", pos); | ||||
if (idx == -1) { | ||||
escaped += htmlEscape(text.slice(pos)); | ||||
col += text.length - pos; | ||||
break; | ||||
} else { | ||||
col += idx - pos; | ||||
var tab = makeTab(col); | ||||
escaped += htmlEscape(text.slice(pos, idx)) + tab.html; | ||||
col += tab.width; | ||||
pos = idx + 1; | ||||
} | ||||
} | ||||
} | ||||
if (style) html.push('<span class="', style, '">', escaped, "</span>"); | ||||
else html.push(escaped); | ||||
} | ||||
var span = span_; | ||||
if (wrapAt != null) { | ||||
var outPos = 0, open = "<span id=\"" + wrapId + "\">"; | ||||
span = function(text, style) { | ||||
var l = text.length; | ||||
if (wrapAt >= outPos && wrapAt < outPos + l) { | ||||
if (wrapAt > outPos) { | ||||
span_(text.slice(0, wrapAt - outPos), style); | ||||
// See comment at the definition of spanAffectsWrapping | ||||
if (wrapWBR) html.push("<wbr>"); | ||||
} | ||||
html.push(open); | ||||
var cut = wrapAt - outPos; | ||||
span_(opera ? text.slice(cut, cut + 1) : text.slice(cut), style); | ||||
html.push("</span>"); | ||||
if (opera) span_(text.slice(cut + 1), style); | ||||
wrapAt--; | ||||
outPos += l; | ||||
} else { | ||||
outPos += l; | ||||
span_(text, style); | ||||
// Output empty wrapper when at end of line | ||||
// (Gecko and IE8+ do strange wrapping when adding a space | ||||
// to the end of the line. Other browsers don't react well | ||||
// to zero-width spaces. So we do hideous browser sniffing | ||||
// to determine which to use.) | ||||
if (outPos == wrapAt && outPos == len) | ||||
html.push(open + (gecko || (ie && !ie_lt8) ? "​" : " ") + "</span>"); | ||||
// Stop outputting HTML when gone sufficiently far beyond measure | ||||
else if (outPos > wrapAt + 10 && /\s/.test(text)) span = function(){}; | ||||
} | ||||
} | ||||
|
r4504 | } | ||
|
r8053 | |||
|
r4504 | var st = this.styles, allText = this.text, marked = this.marked; | ||
var len = allText.length; | ||||
|
r5970 | function styleToClass(style) { | ||
if (!style) return null; | ||||
return "cm-" + style.replace(/ +/g, " cm-"); | ||||
} | ||||
|
r4504 | |||
|
r8053 | if (!allText && wrapAt == null) { | ||
|
r5970 | span(" "); | ||
|
r8053 | } else if (!marked || !marked.length) { | ||
|
r4504 | for (var i = 0, ch = 0; ch < len; i+=2) { | ||
|
r5941 | var str = st[i], style = st[i+1], l = str.length; | ||
|
r4504 | if (ch + l > len) str = str.slice(0, len - ch); | ||
ch += l; | ||||
|
r5970 | span(str, styleToClass(style)); | ||
|
r4504 | } | ||
|
r8053 | } else { | ||
|
r4504 | var pos = 0, i = 0, text = "", style, sg = 0; | ||
|
r5970 | var nextChange = marked[0].from || 0, marks = [], markpos = 0; | ||
function advanceMarks() { | ||||
var m; | ||||
while (markpos < marked.length && | ||||
((m = marked[markpos]).from == pos || m.from == null)) { | ||||
if (m.style != null) marks.push(m); | ||||
++markpos; | ||||
} | ||||
nextChange = markpos < marked.length ? marked[markpos].from : Infinity; | ||||
for (var i = 0; i < marks.length; ++i) { | ||||
|
r8053 | var to = marks[i].to; | ||
if (to == null) to = Infinity; | ||||
|
r5970 | if (to == pos) marks.splice(i--, 1); | ||
else nextChange = Math.min(to, nextChange); | ||||
|
r4504 | } | ||
} | ||||
|
r5970 | var m = 0; | ||
|
r4504 | while (pos < len) { | ||
|
r5970 | if (nextChange == pos) advanceMarks(); | ||
var upto = Math.min(len, nextChange); | ||||
while (true) { | ||||
if (text) { | ||||
var end = pos + text.length; | ||||
var appliedStyle = style; | ||||
for (var j = 0; j < marks.length; ++j) | ||||
appliedStyle = (appliedStyle ? appliedStyle + " " : "") + marks[j].style; | ||||
span(end > upto ? text.slice(0, upto - pos) : text, appliedStyle); | ||||
if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;} | ||||
pos = end; | ||||
|
r4504 | } | ||
|
r5970 | text = st[i++]; style = styleToClass(st[i++]); | ||
|
r4504 | } | ||
} | ||||
} | ||||
return html.join(""); | ||||
|
r5941 | }, | ||
cleanUp: function() { | ||||
this.parent = null; | ||||
if (this.marked) | ||||
for (var i = 0, e = this.marked.length; i < e; ++i) this.marked[i].detach(this); | ||||
|
r4504 | } | ||
}; | ||||
// Utility used by replace and split above | ||||
function copyStyles(from, to, source, dest) { | ||||
for (var i = 0, pos = 0, state = 0; pos < to; i+=2) { | ||||
var part = source[i], end = pos + part.length; | ||||
if (state == 0) { | ||||
if (end > from) dest.push(part.slice(from - pos, Math.min(part.length, to - pos)), source[i+1]); | ||||
if (end >= from) state = 1; | ||||
|
r8053 | } else if (state == 1) { | ||
|
r4504 | if (end > to) dest.push(part.slice(0, to - pos), source[i+1]); | ||
else dest.push(part, source[i+1]); | ||||
} | ||||
pos = end; | ||||
} | ||||
} | ||||
|
r5941 | // Data structure that holds the sequence of lines. | ||
function LeafChunk(lines) { | ||||
this.lines = lines; | ||||
this.parent = null; | ||||
for (var i = 0, e = lines.length, height = 0; i < e; ++i) { | ||||
lines[i].parent = this; | ||||
height += lines[i].height; | ||||
} | ||||
this.height = height; | ||||
} | ||||
LeafChunk.prototype = { | ||||
chunkSize: function() { return this.lines.length; }, | ||||
remove: function(at, n, callbacks) { | ||||
for (var i = at, e = at + n; i < e; ++i) { | ||||
var line = this.lines[i]; | ||||
this.height -= line.height; | ||||
line.cleanUp(); | ||||
if (line.handlers) | ||||
for (var j = 0; j < line.handlers.length; ++j) callbacks.push(line.handlers[j]); | ||||
} | ||||
this.lines.splice(at, n); | ||||
}, | ||||
collapse: function(lines) { | ||||
lines.splice.apply(lines, [lines.length, 0].concat(this.lines)); | ||||
}, | ||||
insertHeight: function(at, lines, height) { | ||||
this.height += height; | ||||
|
r8053 | this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at)); | ||
|
r5941 | for (var i = 0, e = lines.length; i < e; ++i) lines[i].parent = this; | ||
}, | ||||
iterN: function(at, n, op) { | ||||
for (var e = at + n; at < e; ++at) | ||||
if (op(this.lines[at])) return true; | ||||
} | ||||
}; | ||||
function BranchChunk(children) { | ||||
this.children = children; | ||||
var size = 0, height = 0; | ||||
for (var i = 0, e = children.length; i < e; ++i) { | ||||
var ch = children[i]; | ||||
size += ch.chunkSize(); height += ch.height; | ||||
ch.parent = this; | ||||
} | ||||
this.size = size; | ||||
this.height = height; | ||||
this.parent = null; | ||||
} | ||||
BranchChunk.prototype = { | ||||
chunkSize: function() { return this.size; }, | ||||
remove: function(at, n, callbacks) { | ||||
this.size -= n; | ||||
for (var i = 0; i < this.children.length; ++i) { | ||||
var child = this.children[i], sz = child.chunkSize(); | ||||
if (at < sz) { | ||||
var rm = Math.min(n, sz - at), oldHeight = child.height; | ||||
child.remove(at, rm, callbacks); | ||||
this.height -= oldHeight - child.height; | ||||
if (sz == rm) { this.children.splice(i--, 1); child.parent = null; } | ||||
if ((n -= rm) == 0) break; | ||||
at = 0; | ||||
} else at -= sz; | ||||
} | ||||
if (this.size - n < 25) { | ||||
var lines = []; | ||||
this.collapse(lines); | ||||
this.children = [new LeafChunk(lines)]; | ||||
|
r5970 | this.children[0].parent = this; | ||
|
r5941 | } | ||
}, | ||||
collapse: function(lines) { | ||||
for (var i = 0, e = this.children.length; i < e; ++i) this.children[i].collapse(lines); | ||||
}, | ||||
insert: function(at, lines) { | ||||
var height = 0; | ||||
for (var i = 0, e = lines.length; i < e; ++i) height += lines[i].height; | ||||
this.insertHeight(at, lines, height); | ||||
}, | ||||
insertHeight: function(at, lines, height) { | ||||
this.size += lines.length; | ||||
this.height += height; | ||||
for (var i = 0, e = this.children.length; i < e; ++i) { | ||||
var child = this.children[i], sz = child.chunkSize(); | ||||
if (at <= sz) { | ||||
child.insertHeight(at, lines, height); | ||||
if (child.lines && child.lines.length > 50) { | ||||
while (child.lines.length > 50) { | ||||
var spilled = child.lines.splice(child.lines.length - 25, 25); | ||||
var newleaf = new LeafChunk(spilled); | ||||
child.height -= newleaf.height; | ||||
this.children.splice(i + 1, 0, newleaf); | ||||
newleaf.parent = this; | ||||
} | ||||
this.maybeSpill(); | ||||
} | ||||
break; | ||||
} | ||||
at -= sz; | ||||
} | ||||
}, | ||||
maybeSpill: function() { | ||||
if (this.children.length <= 10) return; | ||||
var me = this; | ||||
do { | ||||
var spilled = me.children.splice(me.children.length - 5, 5); | ||||
var sibling = new BranchChunk(spilled); | ||||
if (!me.parent) { // Become the parent node | ||||
var copy = new BranchChunk(me.children); | ||||
copy.parent = me; | ||||
me.children = [copy, sibling]; | ||||
me = copy; | ||||
} else { | ||||
me.size -= sibling.size; | ||||
me.height -= sibling.height; | ||||
var myIndex = indexOf(me.parent.children, me); | ||||
me.parent.children.splice(myIndex + 1, 0, sibling); | ||||
} | ||||
sibling.parent = me.parent; | ||||
} while (me.children.length > 10); | ||||
me.parent.maybeSpill(); | ||||
}, | ||||
iter: function(from, to, op) { this.iterN(from, to - from, op); }, | ||||
iterN: function(at, n, op) { | ||||
for (var i = 0, e = this.children.length; i < e; ++i) { | ||||
var child = this.children[i], sz = child.chunkSize(); | ||||
if (at < sz) { | ||||
var used = Math.min(n, sz - at); | ||||
if (child.iterN(at, used, op)) return true; | ||||
if ((n -= used) == 0) break; | ||||
at = 0; | ||||
} else at -= sz; | ||||
} | ||||
} | ||||
}; | ||||
function getLineAt(chunk, n) { | ||||
while (!chunk.lines) { | ||||
for (var i = 0;; ++i) { | ||||
var child = chunk.children[i], sz = child.chunkSize(); | ||||
if (n < sz) { chunk = child; break; } | ||||
n -= sz; | ||||
} | ||||
} | ||||
return chunk.lines[n]; | ||||
} | ||||
function lineNo(line) { | ||||
if (line.parent == null) return null; | ||||
var cur = line.parent, no = indexOf(cur.lines, line); | ||||
for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) { | ||||
for (var i = 0, e = chunk.children.length; ; ++i) { | ||||
if (chunk.children[i] == cur) break; | ||||
no += chunk.children[i].chunkSize(); | ||||
} | ||||
} | ||||
return no; | ||||
} | ||||
function lineAtHeight(chunk, h) { | ||||
var n = 0; | ||||
outer: do { | ||||
for (var i = 0, e = chunk.children.length; i < e; ++i) { | ||||
var child = chunk.children[i], ch = child.height; | ||||
if (h < ch) { chunk = child; continue outer; } | ||||
h -= ch; | ||||
n += child.chunkSize(); | ||||
} | ||||
return n; | ||||
} while (!chunk.lines); | ||||
for (var i = 0, e = chunk.lines.length; i < e; ++i) { | ||||
var line = chunk.lines[i], lh = line.height; | ||||
if (h < lh) break; | ||||
h -= lh; | ||||
} | ||||
return n + i; | ||||
} | ||||
function heightAtLine(chunk, n) { | ||||
var h = 0; | ||||
outer: do { | ||||
for (var i = 0, e = chunk.children.length; i < e; ++i) { | ||||
var child = chunk.children[i], sz = child.chunkSize(); | ||||
if (n < sz) { chunk = child; continue outer; } | ||||
n -= sz; | ||||
h += child.height; | ||||
} | ||||
return h; | ||||
} while (!chunk.lines); | ||||
for (var i = 0; i < n; ++i) h += chunk.lines[i].height; | ||||
return h; | ||||
} | ||||
|
r4504 | // The history object 'chunks' changes that are made close together | ||
// and at almost the same time into bigger undoable units. | ||||
function History() { | ||||
this.time = 0; | ||||
this.done = []; this.undone = []; | ||||
|
r8053 | this.compound = 0; | ||
this.closed = false; | ||||
|
r4504 | } | ||
History.prototype = { | ||||
addChange: function(start, added, old) { | ||||
this.undone.length = 0; | ||||
|
r6058 | var time = +new Date, cur = this.done[this.done.length - 1], last = cur && cur[cur.length - 1]; | ||
var dtime = time - this.time; | ||||
|
r8053 | |||
if (this.compound && cur && !this.closed) { | ||||
|
r6058 | cur.push({start: start, added: added, old: old}); | ||
|
r8053 | } else if (dtime > 400 || !last || this.closed || | ||
last.start > start + old.length || last.start + last.added < start) { | ||||
this.done.push([{start: start, added: added, old: old}]); | ||||
this.closed = false; | ||||
|
r6058 | } else { | ||
|
r8053 | var startBefore = Math.max(0, last.start - start), | ||
endAfter = Math.max(0, (start + old.length) - (last.start + last.added)); | ||||
for (var i = startBefore; i > 0; --i) last.old.unshift(old[i - 1]); | ||||
for (var i = endAfter; i > 0; --i) last.old.push(old[old.length - i]); | ||||
if (startBefore) last.start = start; | ||||
last.added += added - (old.length - startBefore - endAfter); | ||||
|
r4504 | } | ||
this.time = time; | ||||
|
r8053 | }, | ||
startCompound: function() { | ||||
if (!this.compound++) this.closed = true; | ||||
}, | ||||
endCompound: function() { | ||||
if (!--this.compound) this.closed = true; | ||||
|
r4504 | } | ||
}; | ||||
function stopMethod() {e_stop(this);} | ||||
// Ensure an event has a stop method. | ||||
function addStop(event) { | ||||
if (!event.stop) event.stop = stopMethod; | ||||
return event; | ||||
} | ||||
function e_preventDefault(e) { | ||||
if (e.preventDefault) e.preventDefault(); | ||||
else e.returnValue = false; | ||||
} | ||||
function e_stopPropagation(e) { | ||||
if (e.stopPropagation) e.stopPropagation(); | ||||
else e.cancelBubble = true; | ||||
} | ||||
function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);} | ||||
|
r5941 | CodeMirror.e_stop = e_stop; | ||
CodeMirror.e_preventDefault = e_preventDefault; | ||||
CodeMirror.e_stopPropagation = e_stopPropagation; | ||||
|
r4504 | function e_target(e) {return e.target || e.srcElement;} | ||
function e_button(e) { | ||||
|
r8053 | var b = e.which; | ||
if (b == null) { | ||||
if (e.button & 1) b = 1; | ||||
else if (e.button & 2) b = 3; | ||||
else if (e.button & 4) b = 2; | ||||
} | ||||
if (mac && e.ctrlKey && b == 1) b = 3; | ||||
return b; | ||||
|
r4504 | } | ||
|
r5970 | // Allow 3rd-party code to override event properties by adding an override | ||
// object to an event object. | ||||
function e_prop(e, prop) { | ||||
var overridden = e.override && e.override.hasOwnProperty(prop); | ||||
return overridden ? e.override[prop] : e[prop]; | ||||
} | ||||
|
r4504 | // Event handler registration. If disconnect is true, it'll return a | ||
// function that unregisters the handler. | ||||
function connect(node, type, handler, disconnect) { | ||||
if (typeof node.addEventListener == "function") { | ||||
|
r5941 | node.addEventListener(type, handler, false); | ||
if (disconnect) return function() {node.removeEventListener(type, handler, false);}; | ||||
|
r8053 | } else { | ||
|
r5941 | var wrapHandler = function(event) {handler(event || window.event);}; | ||
|
r4504 | node.attachEvent("on" + type, wrapHandler); | ||
if (disconnect) return function() {node.detachEvent("on" + type, wrapHandler);}; | ||||
} | ||||
} | ||||
|
r5941 | CodeMirror.connect = connect; | ||
|
r4504 | |||
function Delayed() {this.id = null;} | ||||
Delayed.prototype = {set: function(ms, f) {clearTimeout(this.id); this.id = setTimeout(f, ms);}}; | ||||
|
r8053 | var Pass = CodeMirror.Pass = {toString: function(){return "CodeMirror.Pass";}}; | ||
|
r4933 | |||
|
r4504 | var gecko = /gecko\/\d{7}/i.test(navigator.userAgent); | ||
var ie = /MSIE \d/.test(navigator.userAgent); | ||||
|
r8053 | var ie_lt8 = /MSIE [1-7]\b/.test(navigator.userAgent); | ||
var ie_lt9 = /MSIE [1-8]\b/.test(navigator.userAgent); | ||||
var quirksMode = ie && document.documentMode == 5; | ||||
|
r5941 | var webkit = /WebKit\//.test(navigator.userAgent); | ||
|
r8053 | var chrome = /Chrome\//.test(navigator.userAgent); | ||
var opera = /Opera\//.test(navigator.userAgent); | ||||
var safari = /Apple Computer/.test(navigator.vendor); | ||||
var khtml = /KHTML\//.test(navigator.userAgent); | ||||
var mac_geLion = /Mac OS X 10\D([7-9]|\d\d)\D/.test(navigator.userAgent); | ||||
// Detect drag-and-drop | ||||
var dragAndDrop = function() { | ||||
// There is *some* kind of drag-and-drop support in IE6-8, but I | ||||
// couldn't get it to work yet. | ||||
if (ie_lt9) return false; | ||||
var div = document.createElement('div'); | ||||
return "draggable" in div || "dragDrop" in div; | ||||
}(); | ||||
|
r4504 | |||
// Feature-detect whether newlines in textareas are converted to \r\n | ||||
|
r8053 | var lineSep = function () { | ||
|
r4504 | var te = document.createElement("textarea"); | ||
te.value = "foo\nbar"; | ||||
|
r8053 | if (te.value.indexOf("\r") > -1) return "\r\n"; | ||
return "\n"; | ||||
}(); | ||||
// For a reason I have yet to figure out, some browsers disallow | ||||
// word wrapping between certain characters *only* if a new inline | ||||
// element is started between them. This makes it hard to reliably | ||||
// measure the position of things, since that requires inserting an | ||||
// extra span. This terribly fragile set of regexps matches the | ||||
// character combinations that suffer from this phenomenon on the | ||||
// various browsers. | ||||
var spanAffectsWrapping = /^$/; // Won't match any two-character string | ||||
if (gecko) spanAffectsWrapping = /$'/; | ||||
else if (safari) spanAffectsWrapping = /\-[^ \-?]|\?[^ !'\"\),.\-\/:;\?\]\}]/; | ||||
else if (chrome) spanAffectsWrapping = /\-[^ \-\.?]|\?[^ \-\.?\]\}:;!'\"\),\/]|[\.!\"#&%\)*+,:;=>\]|\}~][\(\{\[<]|\$'/; | ||||
|
r4504 | |||
// Counts the column offset in a string, taking tabs into account. | ||||
// Used mostly to find indentation. | ||||
|
r5941 | function countColumn(string, end, tabSize) { | ||
|
r4504 | if (end == null) { | ||
end = string.search(/[^\s\u00a0]/); | ||||
if (end == -1) end = string.length; | ||||
} | ||||
for (var i = 0, n = 0; i < end; ++i) { | ||||
if (string.charAt(i) == "\t") n += tabSize - (n % tabSize); | ||||
else ++n; | ||||
} | ||||
return n; | ||||
} | ||||
function computedStyle(elt) { | ||||
if (elt.currentStyle) return elt.currentStyle; | ||||
return window.getComputedStyle(elt, null); | ||||
} | ||||
|
r5941 | |||
|
r4504 | function eltOffset(node, screen) { | ||
|
r5941 | // Take the parts of bounding client rect that we are interested in so we are able to edit if need be, | ||
// since the returned value cannot be changed externally (they are kept in sync as the element moves within the page) | ||||
try { var box = node.getBoundingClientRect(); box = { top: box.top, left: box.left }; } | ||||
catch(e) { box = {top: 0, left: 0}; } | ||||
if (!screen) { | ||||
// Get the toplevel scroll, working around browser differences. | ||||
if (window.pageYOffset == null) { | ||||
var t = document.documentElement || document.body.parentNode; | ||||
if (t.scrollTop == null) t = document.body; | ||||
box.top += t.scrollTop; box.left += t.scrollLeft; | ||||
} else { | ||||
box.top += window.pageYOffset; box.left += window.pageXOffset; | ||||
} | ||||
} | ||||
return box; | ||||
|
r8053 | } | ||
|
r5941 | |||
|
r4504 | // Get a node's text content. | ||
function eltText(node) { | ||||
return node.textContent || node.innerText || node.nodeValue || ""; | ||||
} | ||||
|
r5970 | function selectInput(node) { | ||
if (ios) { // Mobile Safari apparently has a bug where select() is broken. | ||||
node.selectionStart = 0; | ||||
node.selectionEnd = node.value.length; | ||||
} else node.select(); | ||||
} | ||||
|
r4504 | |||
// Operations on {line, ch} objects. | ||||
function posEq(a, b) {return a.line == b.line && a.ch == b.ch;} | ||||
function posLess(a, b) {return a.line < b.line || (a.line == b.line && a.ch < b.ch);} | ||||
function copyPos(x) {return {line: x.line, ch: x.ch};} | ||||
|
r5941 | var escapeElement = document.createElement("pre"); | ||
|
r4504 | function htmlEscape(str) { | ||
|
r5941 | escapeElement.textContent = str; | ||
|
r4504 | return escapeElement.innerHTML; | ||
} | ||||
|
r5941 | // Recent (late 2011) Opera betas insert bogus newlines at the start | ||
// of the textContent, so we strip those. | ||||
|
r8053 | if (htmlEscape("a") == "\na") { | ||
|
r5941 | htmlEscape = function(str) { | ||
escapeElement.textContent = str; | ||||
return escapeElement.innerHTML.slice(1); | ||||
}; | ||||
// Some IEs don't preserve tabs through innerHTML | ||||
|
r8053 | } else if (htmlEscape("\t") != "\t") { | ||
|
r5941 | htmlEscape = function(str) { | ||
escapeElement.innerHTML = ""; | ||||
escapeElement.appendChild(document.createTextNode(str)); | ||||
return escapeElement.innerHTML; | ||||
}; | ||||
|
r8053 | } | ||
|
r4504 | CodeMirror.htmlEscape = htmlEscape; | ||
// Used to position the cursor after an undo/redo by finding the | ||||
// last edited character. | ||||
function editEnd(from, to) { | ||||
|
r5970 | if (!to) return 0; | ||
|
r4504 | if (!from) return to.length; | ||
for (var i = from.length, j = to.length; i >= 0 && j >= 0; --i, --j) | ||||
if (from.charAt(i) != to.charAt(j)) break; | ||||
return j + 1; | ||||
} | ||||
function indexOf(collection, elt) { | ||||
if (collection.indexOf) return collection.indexOf(elt); | ||||
for (var i = 0, e = collection.length; i < e; ++i) | ||||
if (collection[i] == elt) return i; | ||||
return -1; | ||||
} | ||||
|
r5941 | function isWordChar(ch) { | ||
return /\w/.test(ch) || ch.toUpperCase() != ch.toLowerCase(); | ||||
} | ||||
|
r4504 | |||
// See if "".split is the broken IE version, if so, provide an | ||||
// alternative way to split lines. | ||||
|
r5941 | var splitLines = "\n\nb".split(/\n/).length != 3 ? function(string) { | ||
|
r8053 | var pos = 0, result = [], l = string.length; | ||
while (pos <= l) { | ||||
var nl = string.indexOf("\n", pos); | ||||
if (nl == -1) nl = string.length; | ||||
var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl); | ||||
var rt = line.indexOf("\r"); | ||||
if (rt != -1) { | ||||
result.push(line.slice(0, rt)); | ||||
pos += rt + 1; | ||||
} else { | ||||
result.push(line); | ||||
pos = nl + 1; | ||||
} | ||||
|
r5941 | } | ||
return result; | ||||
|
r8053 | } : function(string){return string.split(/\r\n?|\n/);}; | ||
|
r4504 | CodeMirror.splitLines = splitLines; | ||
|
r5941 | var hasSelection = window.getSelection ? function(te) { | ||
try { return te.selectionStart != te.selectionEnd; } | ||||
catch(e) { return false; } | ||||
} : function(te) { | ||||
try {var range = te.ownerDocument.selection.createRange();} | ||||
catch(e) {} | ||||
if (!range || range.parentElement() != te) return false; | ||||
return range.compareEndPoints("StartToEnd", range) != 0; | ||||
}; | ||||
|
r4504 | |||
CodeMirror.defineMode("null", function() { | ||||
return {token: function(stream) {stream.skipToEnd();}}; | ||||
}); | ||||
CodeMirror.defineMIME("text/plain", "null"); | ||||
|
r5941 | var keyNames = {3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt", | ||
19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End", | ||||
36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert", | ||||
|
r8053 | 46: "Delete", 59: ";", 91: "Mod", 92: "Mod", 93: "Mod", 109: "-", 107: "=", 127: "Delete", | ||
186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\", | ||||
221: "]", 222: "'", 63276: "PageUp", 63277: "PageDown", 63275: "End", 63273: "Home", | ||||
63234: "Left", 63232: "Up", 63235: "Right", 63233: "Down", 63302: "Insert", 63272: "Delete"}; | ||||
|
r5941 | CodeMirror.keyNames = keyNames; | ||
(function() { | ||||
// Number keys | ||||
for (var i = 0; i < 10; i++) keyNames[i + 48] = String(i); | ||||
// Alphabetic keys | ||||
for (var i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i); | ||||
// Function keys | ||||
for (var i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i; | ||||
})(); | ||||
|
r4504 | return CodeMirror; | ||
|
r4933 | })(); | ||