[Kimchi-devel] [PATCH v3] [Kimchi 4/8] Import term.js to Kimchi project
Jose Ricardo Ziviani
joserz at linux.vnet.ibm.com
Thu Feb 11 13:47:06 UTC 2016
- term.js project (https://github.com/chjj/term.js) is a xterm clone
written in javascript and distributed under MIT license.
Signed-off-by: Jose Ricardo Ziviani <joserz at linux.vnet.ibm.com>
---
COPYING | 2 +
ui/serial/libs/term.js | 5973 ++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 5975 insertions(+)
create mode 100644 ui/serial/libs/term.js
diff --git a/COPYING b/COPYING
index 39ec3ba..2c10c02 100644
--- a/COPYING
+++ b/COPYING
@@ -6,6 +6,8 @@ Apache License version 2.0.
Kimchi makes use of different projects and they are placed as below:
- the code under ui/spice-html5 is imported from spice-html5 project
(http://cgit.freedesktop.org/spice/spice-html5);
+- the code under ui/serial/libs is imported from term.js project
+(https://github.com/chjj/term.js) under MIT license;
The rest of this distribution is governed by the GNU Lesser General Public
License version 2.1.
diff --git a/ui/serial/libs/term.js b/ui/serial/libs/term.js
new file mode 100644
index 0000000..f542dd0
--- /dev/null
+++ b/ui/serial/libs/term.js
@@ -0,0 +1,5973 @@
+/**
+ * term.js - an xterm emulator
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * https://github.com/chjj/term.js
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Originally forked from (with the author's permission):
+ * Fabrice Bellard's javascript vt100 for jslinux:
+ * http://bellard.org/jslinux/
+ * Copyright (c) 2011 Fabrice Bellard
+ * The original design remains. The terminal itself
+ * has been extended to include xterm CSI codes, among
+ * other features.
+ */
+
+;(function() {
+
+/**
+ * Terminal Emulation References:
+ * http://vt100.net/
+ * http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt
+ * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ * http://invisible-island.net/vttest/
+ * http://www.inwap.com/pdp10/ansicode.txt
+ * http://linux.die.net/man/4/console_codes
+ * http://linux.die.net/man/7/urxvt
+ */
+
+'use strict';
+
+/**
+ * Shared
+ */
+
+var window = this
+ , document = this.document;
+
+/**
+ * EventEmitter
+ */
+
+function EventEmitter() {
+ this._events = this._events || {};
+}
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ this._events[type] = this._events[type] || [];
+ this._events[type].push(listener);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+ if (!this._events[type]) return;
+
+ var obj = this._events[type]
+ , i = obj.length;
+
+ while (i--) {
+ if (obj[i] === listener || obj[i].listener === listener) {
+ obj.splice(i, 1);
+ return;
+ }
+ }
+};
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ if (this._events[type]) delete this._events[type];
+};
+
+EventEmitter.prototype.once = function(type, listener) {
+ function on() {
+ var args = Array.prototype.slice.call(arguments);
+ this.removeListener(type, on);
+ return listener.apply(this, args);
+ }
+ on.listener = listener;
+ return this.on(type, on);
+};
+
+EventEmitter.prototype.emit = function(type) {
+ if (!this._events[type]) return;
+
+ var args = Array.prototype.slice.call(arguments, 1)
+ , obj = this._events[type]
+ , l = obj.length
+ , i = 0;
+
+ for (; i < l; i++) {
+ obj[i].apply(this, args);
+ }
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ return this._events[type] = this._events[type] || [];
+};
+
+/**
+ * Stream
+ */
+
+function Stream() {
+ EventEmitter.call(this);
+}
+
+inherits(Stream, EventEmitter);
+
+Stream.prototype.pipe = function(dest, options) {
+ var src = this
+ , ondata
+ , onerror
+ , onend;
+
+ function unbind() {
+ src.removeListener('data', ondata);
+ src.removeListener('error', onerror);
+ src.removeListener('end', onend);
+ dest.removeListener('error', onerror);
+ dest.removeListener('close', unbind);
+ }
+
+ src.on('data', ondata = function(data) {
+ dest.write(data);
+ });
+
+ src.on('error', onerror = function(err) {
+ unbind();
+ if (!this.listeners('error').length) {
+ throw err;
+ }
+ });
+
+ src.on('end', onend = function() {
+ dest.end();
+ unbind();
+ });
+
+ dest.on('error', onerror);
+ dest.on('close', unbind);
+
+ dest.emit('pipe', src);
+
+ return dest;
+};
+
+/**
+ * States
+ */
+
+var normal = 0
+ , escaped = 1
+ , csi = 2
+ , osc = 3
+ , charset = 4
+ , dcs = 5
+ , ignore = 6
+ , UDK = { type: 'udk' };
+
+/**
+ * Terminal
+ */
+
+function Terminal(options) {
+ var self = this;
+
+ if (!(this instanceof Terminal)) {
+ return new Terminal(arguments[0], arguments[1], arguments[2]);
+ }
+
+ Stream.call(this);
+
+ if (typeof options === 'number') {
+ options = {
+ cols: arguments[0],
+ rows: arguments[1],
+ handler: arguments[2]
+ };
+ }
+
+ options = options || {};
+
+ each(keys(Terminal.defaults), function(key) {
+ if (options[key] == null) {
+ options[key] = Terminal.options[key];
+ // Legacy:
+ if (Terminal[key] !== Terminal.defaults[key]) {
+ options[key] = Terminal[key];
+ }
+ }
+ self[key] = options[key];
+ });
+
+ if (options.colors.length === 8) {
+ options.colors = options.colors.concat(Terminal._colors.slice(8));
+ } else if (options.colors.length === 16) {
+ options.colors = options.colors.concat(Terminal._colors.slice(16));
+ } else if (options.colors.length === 10) {
+ options.colors = options.colors.slice(0, -2).concat(
+ Terminal._colors.slice(8, -2), options.colors.slice(-2));
+ } else if (options.colors.length === 18) {
+ options.colors = options.colors.slice(0, -2).concat(
+ Terminal._colors.slice(16, -2), options.colors.slice(-2));
+ }
+ this.colors = options.colors;
+
+ this.options = options;
+
+ // this.context = options.context || window;
+ // this.document = options.document || document;
+ this.parent = options.body || options.parent
+ || (document ? document.getElementsByTagName('body')[0] : null);
+
+ this.cols = options.cols || options.geometry[0];
+ this.rows = options.rows || options.geometry[1];
+
+ // Act as though we are a node TTY stream:
+ this.setRawMode;
+ this.isTTY = true;
+ this.isRaw = true;
+ this.columns = this.cols;
+ this.rows = this.rows;
+
+ if (options.handler) {
+ this.on('data', options.handler);
+ }
+
+ this.ybase = 0;
+ this.ydisp = 0;
+ this.x = 0;
+ this.y = 0;
+ this.cursorState = 0;
+ this.cursorHidden = false;
+ this.convertEol;
+ this.state = 0;
+ this.queue = '';
+ this.scrollTop = 0;
+ this.scrollBottom = this.rows - 1;
+
+ // modes
+ this.applicationKeypad = false;
+ this.applicationCursor = false;
+ this.originMode = false;
+ this.insertMode = false;
+ this.wraparoundMode = false;
+ this.normal = null;
+
+ // select modes
+ this.prefixMode = false;
+ this.selectMode = false;
+ this.visualMode = false;
+ this.searchMode = false;
+ this.searchDown;
+ this.entry = '';
+ this.entryPrefix = 'Search: ';
+ this._real;
+ this._selected;
+ this._textarea;
+
+ // charset
+ this.charset = null;
+ this.gcharset = null;
+ this.glevel = 0;
+ this.charsets = [null];
+
+ // mouse properties
+ this.decLocator;
+ this.x10Mouse;
+ this.vt200Mouse;
+ this.vt300Mouse;
+ this.normalMouse;
+ this.mouseEvents;
+ this.sendFocus;
+ this.utfMouse;
+ this.sgrMouse;
+ this.urxvtMouse;
+
+ // misc
+ this.element;
+ this.children;
+ this.refreshStart;
+ this.refreshEnd;
+ this.savedX;
+ this.savedY;
+ this.savedCols;
+
+ // stream
+ this.readable = true;
+ this.writable = true;
+
+ this.defAttr = (0 << 18) | (257 << 9) | (256 << 0);
+ this.curAttr = this.defAttr;
+
+ this.params = [];
+ this.currentParam = 0;
+ this.prefix = '';
+ this.postfix = '';
+
+ this.lines = [];
+ var i = this.rows;
+ while (i--) {
+ this.lines.push(this.blankLine());
+ }
+
+ this.tabs;
+ this.setupStops();
+}
+
+inherits(Terminal, Stream);
+
+/**
+ * Colors
+ */
+
+// Colors 0-15
+Terminal.tangoColors = [
+ // dark:
+ '#2e3436',
+ '#cc0000',
+ '#4e9a06',
+ '#c4a000',
+ '#3465a4',
+ '#75507b',
+ '#06989a',
+ '#d3d7cf',
+ // bright:
+ '#555753',
+ '#ef2929',
+ '#8ae234',
+ '#fce94f',
+ '#729fcf',
+ '#ad7fa8',
+ '#34e2e2',
+ '#eeeeec'
+];
+
+Terminal.xtermColors = [
+ // dark:
+ '#000000', // black
+ '#cd0000', // red3
+ '#00cd00', // green3
+ '#cdcd00', // yellow3
+ '#0000ee', // blue2
+ '#cd00cd', // magenta3
+ '#00cdcd', // cyan3
+ '#e5e5e5', // gray90
+ // bright:
+ '#7f7f7f', // gray50
+ '#ff0000', // red
+ '#00ff00', // green
+ '#ffff00', // yellow
+ '#5c5cff', // rgb:5c/5c/ff
+ '#ff00ff', // magenta
+ '#00ffff', // cyan
+ '#ffffff' // white
+];
+
+// Colors 0-15 + 16-255
+// Much thanks to TooTallNate for writing this.
+Terminal.colors = (function() {
+ var colors = Terminal.tangoColors.slice()
+ , r = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
+ , i;
+
+ // 16-231
+ i = 0;
+ for (; i < 216; i++) {
+ out(r[(i / 36) % 6 | 0], r[(i / 6) % 6 | 0], r[i % 6]);
+ }
+
+ // 232-255 (grey)
+ i = 0;
+ for (; i < 24; i++) {
+ r = 8 + i * 10;
+ out(r, r, r);
+ }
+
+ function out(r, g, b) {
+ colors.push('#' + hex(r) + hex(g) + hex(b));
+ }
+
+ function hex(c) {
+ c = c.toString(16);
+ return c.length < 2 ? '0' + c : c;
+ }
+
+ return colors;
+})();
+
+// Default BG/FG
+Terminal.colors[256] = '#000000';
+Terminal.colors[257] = '#f0f0f0';
+
+Terminal._colors = Terminal.colors.slice();
+
+Terminal.vcolors = (function() {
+ var out = []
+ , colors = Terminal.colors
+ , i = 0
+ , color;
+
+ for (; i < 256; i++) {
+ color = parseInt(colors[i].substring(1), 16);
+ out.push([
+ (color >> 16) & 0xff,
+ (color >> 8) & 0xff,
+ color & 0xff
+ ]);
+ }
+
+ return out;
+})();
+
+/**
+ * Options
+ */
+
+Terminal.defaults = {
+ colors: Terminal.colors,
+ convertEol: false,
+ termName: 'xterm',
+ geometry: [80, 24],
+ cursorBlink: true,
+ visualBell: false,
+ popOnBell: false,
+ scrollback: 1000,
+ screenKeys: false,
+ debug: false,
+ useStyle: false
+ // programFeatures: false,
+ // focusKeys: false,
+};
+
+Terminal.options = {};
+
+each(keys(Terminal.defaults), function(key) {
+ Terminal[key] = Terminal.defaults[key];
+ Terminal.options[key] = Terminal.defaults[key];
+});
+
+/**
+ * Focused Terminal
+ */
+
+Terminal.focus = null;
+
+Terminal.prototype.focus = function() {
+ if (Terminal.focus === this) return;
+
+ if (Terminal.focus) {
+ Terminal.focus.blur();
+ }
+
+ if (this.sendFocus) this.send('\x1b[I');
+ this.showCursor();
+
+ // try {
+ // this.element.focus();
+ // } catch (e) {
+ // ;
+ // }
+
+ // this.emit('focus');
+
+ Terminal.focus = this;
+};
+
+Terminal.prototype.blur = function() {
+ if (Terminal.focus !== this) return;
+
+ this.cursorState = 0;
+ this.refresh(this.y, this.y);
+ if (this.sendFocus) this.send('\x1b[O');
+
+ // try {
+ // this.element.blur();
+ // } catch (e) {
+ // ;
+ // }
+
+ // this.emit('blur');
+
+ Terminal.focus = null;
+};
+
+/**
+ * Initialize global behavior
+ */
+
+Terminal.prototype.initGlobal = function() {
+ var document = this.document;
+
+ Terminal._boundDocs = Terminal._boundDocs || [];
+ if (~indexOf(Terminal._boundDocs, document)) {
+ return;
+ }
+ Terminal._boundDocs.push(document);
+
+ Terminal.bindPaste(document);
+
+ Terminal.bindKeys(document);
+
+ Terminal.bindCopy(document);
+
+ if (this.isMobile) {
+ this.fixMobile(document);
+ }
+
+ if (this.useStyle) {
+ Terminal.insertStyle(document, this.colors[256], this.colors[257]);
+ }
+};
+
+/**
+ * Bind to paste event
+ */
+
+Terminal.bindPaste = function(document) {
+ // This seems to work well for ctrl-V and middle-click,
+ // even without the contentEditable workaround.
+ var window = document.defaultView;
+ on(window, 'paste', function(ev) {
+ var term = Terminal.focus;
+ if (!term) return;
+ if (ev.clipboardData) {
+ term.send(ev.clipboardData.getData('text/plain'));
+ } else if (term.context.clipboardData) {
+ term.send(term.context.clipboardData.getData('Text'));
+ }
+ // Not necessary. Do it anyway for good measure.
+ term.element.contentEditable = 'inherit';
+ return cancel(ev);
+ });
+};
+
+/**
+ * Global Events for key handling
+ */
+
+Terminal.bindKeys = function(document) {
+ // We should only need to check `target === body` below,
+ // but we can check everything for good measure.
+ on(document, 'keydown', function(ev) {
+ if (!Terminal.focus) return;
+ var target = ev.target || ev.srcElement;
+ if (!target) return;
+ if (target === Terminal.focus.element
+ || target === Terminal.focus.context
+ || target === Terminal.focus.document
+ || target === Terminal.focus.body
+ || target === Terminal._textarea
+ || target === Terminal.focus.parent) {
+ return Terminal.focus.keyDown(ev);
+ }
+ }, true);
+
+ on(document, 'keypress', function(ev) {
+ if (!Terminal.focus) return;
+ var target = ev.target || ev.srcElement;
+ if (!target) return;
+ if (target === Terminal.focus.element
+ || target === Terminal.focus.context
+ || target === Terminal.focus.document
+ || target === Terminal.focus.body
+ || target === Terminal._textarea
+ || target === Terminal.focus.parent) {
+ return Terminal.focus.keyPress(ev);
+ }
+ }, true);
+
+ // If we click somewhere other than a
+ // terminal, unfocus the terminal.
+ on(document, 'mousedown', function(ev) {
+ if (!Terminal.focus) return;
+
+ var el = ev.target || ev.srcElement;
+ if (!el) return;
+
+ do {
+ if (el === Terminal.focus.element) return;
+ } while (el = el.parentNode);
+
+ Terminal.focus.blur();
+ });
+};
+
+/**
+ * Copy Selection w/ Ctrl-C (Select Mode)
+ */
+
+Terminal.bindCopy = function(document) {
+ var window = document.defaultView;
+
+ // if (!('onbeforecopy' in document)) {
+ // // Copies to *only* the clipboard.
+ // on(window, 'copy', function fn(ev) {
+ // var term = Terminal.focus;
+ // if (!term) return;
+ // if (!term._selected) return;
+ // var text = term.grabText(
+ // term._selected.x1, term._selected.x2,
+ // term._selected.y1, term._selected.y2);
+ // term.emit('copy', text);
+ // ev.clipboardData.setData('text/plain', text);
+ // });
+ // return;
+ // }
+
+ // Copies to primary selection *and* clipboard.
+ // NOTE: This may work better on capture phase,
+ // or using the `beforecopy` event.
+ on(window, 'copy', function(ev) {
+ var term = Terminal.focus;
+ if (!term) return;
+ if (!term._selected) return;
+ var textarea = term.getCopyTextarea();
+ var text = term.grabText(
+ term._selected.x1, term._selected.x2,
+ term._selected.y1, term._selected.y2);
+ term.emit('copy', text);
+ textarea.focus();
+ textarea.textContent = text;
+ textarea.value = text;
+ textarea.setSelectionRange(0, text.length);
+ setTimeout(function() {
+ term.element.focus();
+ term.focus();
+ }, 1);
+ });
+};
+
+/**
+ * Fix Mobile
+ */
+
+Terminal.prototype.fixMobile = function(document) {
+ var self = this;
+
+ var textarea = document.createElement('textarea');
+ textarea.style.position = 'absolute';
+ textarea.style.left = '-32000px';
+ textarea.style.top = '-32000px';
+ textarea.style.width = '0px';
+ textarea.style.height = '0px';
+ textarea.style.opacity = '0';
+ textarea.style.backgroundColor = 'transparent';
+ textarea.style.borderStyle = 'none';
+ textarea.style.outlineStyle = 'none';
+ textarea.autocapitalize = 'none';
+ textarea.autocorrect = 'off';
+
+ document.getElementsByTagName('body')[0].appendChild(textarea);
+
+ Terminal._textarea = textarea;
+
+ setTimeout(function() {
+ textarea.focus();
+ }, 1000);
+
+ if (this.isAndroid) {
+ on(textarea, 'change', function() {
+ var value = textarea.textContent || textarea.value;
+ textarea.value = '';
+ textarea.textContent = '';
+ self.send(value + '\r');
+ });
+ }
+};
+
+/**
+ * Insert a default style
+ */
+
+Terminal.insertStyle = function(document, bg, fg) {
+ var style = document.getElementById('term-style');
+ if (style) return;
+
+ var head = document.getElementsByTagName('head')[0];
+ if (!head) return;
+
+ var style = document.createElement('style');
+ style.id = 'term-style';
+
+ // textContent doesn't work well with IE for <style> elements.
+ style.innerHTML = ''
+ + '.terminal {\n'
+ + ' float: left;\n'
+ + ' border: ' + bg + ' solid 5px;\n'
+ + ' font-family: "DejaVu Sans Mono", "Liberation Mono", monospace;\n'
+ + ' font-size: 11px;\n'
+ + ' color: ' + fg + ';\n'
+ + ' background: ' + bg + ';\n'
+ + '}\n'
+ + '\n'
+ + '.terminal-cursor {\n'
+ + ' color: ' + bg + ';\n'
+ + ' background: ' + fg + ';\n'
+ + '}\n';
+
+ // var out = '';
+ // each(Terminal.colors, function(color, i) {
+ // if (i === 256) {
+ // out += '\n.term-bg-color-default { background-color: ' + color + '; }';
+ // }
+ // if (i === 257) {
+ // out += '\n.term-fg-color-default { color: ' + color + '; }';
+ // }
+ // out += '\n.term-bg-color-' + i + ' { background-color: ' + color + '; }';
+ // out += '\n.term-fg-color-' + i + ' { color: ' + color + '; }';
+ // });
+ // style.innerHTML += out + '\n';
+
+ head.insertBefore(style, head.firstChild);
+};
+
+/**
+ * Open Terminal
+ */
+
+Terminal.prototype.open = function(parent) {
+ var self = this
+ , i = 0
+ , div;
+
+ this.parent = parent || this.parent;
+
+ if (!this.parent) {
+ throw new Error('Terminal requires a parent element.');
+ }
+
+ // Grab global elements.
+ this.context = this.parent.ownerDocument.defaultView;
+ this.document = this.parent.ownerDocument;
+ this.body = this.document.getElementsByTagName('body')[0];
+
+ // Parse user-agent strings.
+ if (this.context.navigator && this.context.navigator.userAgent) {
+ this.isMac = !!~this.context.navigator.userAgent.indexOf('Mac');
+ this.isIpad = !!~this.context.navigator.userAgent.indexOf('iPad');
+ this.isIphone = !!~this.context.navigator.userAgent.indexOf('iPhone');
+ this.isAndroid = !!~this.context.navigator.userAgent.indexOf('Android');
+ this.isMobile = this.isIpad || this.isIphone || this.isAndroid;
+ this.isMSIE = !!~this.context.navigator.userAgent.indexOf('MSIE');
+ }
+
+ // Create our main terminal element.
+ this.element = this.document.createElement('div');
+ this.element.className = 'terminal';
+ this.element.style.outline = 'none';
+ this.element.setAttribute('tabindex', 0);
+ this.element.setAttribute('spellcheck', 'false');
+ this.element.style.backgroundColor = this.colors[256];
+ this.element.style.color = this.colors[257];
+
+ // Create the lines for our terminal.
+ this.children = [];
+ for (; i < this.rows; i++) {
+ div = this.document.createElement('div');
+ this.element.appendChild(div);
+ this.children.push(div);
+ }
+ this.parent.appendChild(this.element);
+
+ // Draw the screen.
+ this.refresh(0, this.rows - 1);
+
+ if (!('useEvents' in this.options) || this.options.useEvents) {
+ // Initialize global actions that
+ // need to be taken on the document.
+ this.initGlobal();
+ }
+
+ if (!('useFocus' in this.options) || this.options.useFocus) {
+ // Ensure there is a Terminal.focus.
+ this.focus();
+
+ // Start blinking the cursor.
+ this.startBlink();
+
+ // Bind to DOM events related
+ // to focus and paste behavior.
+ on(this.element, 'focus', function() {
+ self.focus();
+ if (self.isMobile) {
+ Terminal._textarea.focus();
+ }
+ });
+
+ // This causes slightly funky behavior.
+ // on(this.element, 'blur', function() {
+ // self.blur();
+ // });
+
+ on(this.element, 'mousedown', function() {
+ self.focus();
+ });
+
+ // Clickable paste workaround, using contentEditable.
+ // This probably shouldn't work,
+ // ... but it does. Firefox's paste
+ // event seems to only work for textareas?
+ on(this.element, 'mousedown', function(ev) {
+ var button = ev.button != null
+ ? +ev.button
+ : ev.which != null
+ ? ev.which - 1
+ : null;
+
+ // Does IE9 do this?
+ if (self.isMSIE) {
+ button = button === 1 ? 0 : button === 4 ? 1 : button;
+ }
+
+ if (button !== 2) return;
+
+ self.element.contentEditable = 'true';
+ setTimeout(function() {
+ self.element.contentEditable = 'inherit'; // 'false';
+ }, 1);
+ }, true);
+ }
+
+ if (!('useMouse' in this.options) || this.options.useMouse) {
+ // Listen for mouse events and translate
+ // them into terminal mouse protocols.
+ this.bindMouse();
+ }
+
+ // this.emit('open');
+
+ if (!('useFocus' in this.options) || this.options.useFocus) {
+ // This can be useful for pasting,
+ // as well as the iPad fix.
+ setTimeout(function() {
+ self.element.focus();
+ }, 100);
+ }
+
+ // Figure out whether boldness affects
+ // the character width of monospace fonts.
+ if (Terminal.brokenBold == null) {
+ Terminal.brokenBold = isBoldBroken(this.document);
+ }
+
+ this.emit('open');
+};
+
+Terminal.prototype.setRawMode = function(value) {
+ this.isRaw = !!value;
+};
+
+// XTerm mouse events
+// http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
+// To better understand these
+// the xterm code is very helpful:
+// Relevant files:
+// button.c, charproc.c, misc.c
+// Relevant functions in xterm/button.c:
+// BtnCode, EmitButtonCode, EditorButton, SendMousePosition
+Terminal.prototype.bindMouse = function() {
+ var el = this.element
+ , self = this
+ , pressed = 32;
+
+ var wheelEvent = 'onmousewheel' in this.context
+ ? 'mousewheel'
+ : 'DOMMouseScroll';
+
+ // mouseup, mousedown, mousewheel
+ // left click: ^[[M 3<^[[M#3<
+ // mousewheel up: ^[[M`3>
+ function sendButton(ev) {
+ var button
+ , pos;
+
+ // get the xterm-style button
+ button = getButton(ev);
+
+ // get mouse coordinates
+ pos = getCoords(ev);
+ if (!pos) return;
+
+ sendEvent(button, pos);
+
+ switch (ev.type) {
+ case 'mousedown':
+ pressed = button;
+ break;
+ case 'mouseup':
+ // keep it at the left
+ // button, just in case.
+ pressed = 32;
+ break;
+ case wheelEvent:
+ // nothing. don't
+ // interfere with
+ // `pressed`.
+ break;
+ }
+ }
+
+ // motion example of a left click:
+ // ^[[M 3<^[[M at 4<^[[M at 5<^[[M at 6<^[[M at 7<^[[M#7<
+ function sendMove(ev) {
+ var button = pressed
+ , pos;
+
+ pos = getCoords(ev);
+ if (!pos) return;
+
+ // buttons marked as motions
+ // are incremented by 32
+ button += 32;
+
+ sendEvent(button, pos);
+ }
+
+ // encode button and
+ // position to characters
+ function encode(data, ch) {
+ if (!self.utfMouse) {
+ if (ch === 255) return data.push(0);
+ if (ch > 127) ch = 127;
+ data.push(ch);
+ } else {
+ if (ch === 2047) return data.push(0);
+ if (ch < 127) {
+ data.push(ch);
+ } else {
+ if (ch > 2047) ch = 2047;
+ data.push(0xC0 | (ch >> 6));
+ data.push(0x80 | (ch & 0x3F));
+ }
+ }
+ }
+
+ // send a mouse event:
+ // regular/utf8: ^[[M Cb Cx Cy
+ // urxvt: ^[[ Cb ; Cx ; Cy M
+ // sgr: ^[[ Cb ; Cx ; Cy M/m
+ // vt300: ^[[ 24(1/3/5)~ [ Cx , Cy ] \r
+ // locator: CSI P e ; P b ; P r ; P c ; P p & w
+ function sendEvent(button, pos) {
+ // self.emit('mouse', {
+ // x: pos.x - 32,
+ // y: pos.x - 32,
+ // button: button
+ // });
+
+ if (self.vt300Mouse) {
+ // NOTE: Unstable.
+ // http://www.vt100.net/docs/vt3xx-gp/chapter15.html
+ button &= 3;
+ pos.x -= 32;
+ pos.y -= 32;
+ var data = '\x1b[24';
+ if (button === 0) data += '1';
+ else if (button === 1) data += '3';
+ else if (button === 2) data += '5';
+ else if (button === 3) return;
+ else data += '0';
+ data += '~[' + pos.x + ',' + pos.y + ']\r';
+ self.send(data);
+ return;
+ }
+
+ if (self.decLocator) {
+ // NOTE: Unstable.
+ button &= 3;
+ pos.x -= 32;
+ pos.y -= 32;
+ if (button === 0) button = 2;
+ else if (button === 1) button = 4;
+ else if (button === 2) button = 6;
+ else if (button === 3) button = 3;
+ self.send('\x1b['
+ + button
+ + ';'
+ + (button === 3 ? 4 : 0)
+ + ';'
+ + pos.y
+ + ';'
+ + pos.x
+ + ';'
+ + (pos.page || 0)
+ + '&w');
+ return;
+ }
+
+ if (self.urxvtMouse) {
+ pos.x -= 32;
+ pos.y -= 32;
+ pos.x++;
+ pos.y++;
+ self.send('\x1b[' + button + ';' + pos.x + ';' + pos.y + 'M');
+ return;
+ }
+
+ if (self.sgrMouse) {
+ pos.x -= 32;
+ pos.y -= 32;
+ self.send('\x1b[<'
+ + ((button & 3) === 3 ? button & ~3 : button)
+ + ';'
+ + pos.x
+ + ';'
+ + pos.y
+ + ((button & 3) === 3 ? 'm' : 'M'));
+ return;
+ }
+
+ var data = [];
+
+ encode(data, button);
+ encode(data, pos.x);
+ encode(data, pos.y);
+
+ self.send('\x1b[M' + String.fromCharCode.apply(String, data));
+ }
+
+ function getButton(ev) {
+ var button
+ , shift
+ , meta
+ , ctrl
+ , mod;
+
+ // two low bits:
+ // 0 = left
+ // 1 = middle
+ // 2 = right
+ // 3 = release
+ // wheel up/down:
+ // 1, and 2 - with 64 added
+ switch (ev.type) {
+ case 'mousedown':
+ button = ev.button != null
+ ? +ev.button
+ : ev.which != null
+ ? ev.which - 1
+ : null;
+
+ if (self.isMSIE) {
+ button = button === 1 ? 0 : button === 4 ? 1 : button;
+ }
+ break;
+ case 'mouseup':
+ button = 3;
+ break;
+ case 'DOMMouseScroll':
+ button = ev.detail < 0
+ ? 64
+ : 65;
+ break;
+ case 'mousewheel':
+ button = ev.wheelDeltaY > 0
+ ? 64
+ : 65;
+ break;
+ }
+
+ // next three bits are the modifiers:
+ // 4 = shift, 8 = meta, 16 = control
+ shift = ev.shiftKey ? 4 : 0;
+ meta = ev.metaKey ? 8 : 0;
+ ctrl = ev.ctrlKey ? 16 : 0;
+ mod = shift | meta | ctrl;
+
+ // no mods
+ if (self.vt200Mouse) {
+ // ctrl only
+ mod &= ctrl;
+ } else if (!self.normalMouse) {
+ mod = 0;
+ }
+
+ // increment to SP
+ button = (32 + (mod << 2)) + button;
+
+ return button;
+ }
+
+ // mouse coordinates measured in cols/rows
+ function getCoords(ev) {
+ var x, y, w, h, el;
+
+ // ignore browsers without pageX for now
+ if (ev.pageX == null) return;
+
+ x = ev.pageX;
+ y = ev.pageY;
+ el = self.element;
+
+ // should probably check offsetParent
+ // but this is more portable
+ while (el && el !== self.document.documentElement) {
+ x -= el.offsetLeft;
+ y -= el.offsetTop;
+ el = 'offsetParent' in el
+ ? el.offsetParent
+ : el.parentNode;
+ }
+
+ // convert to cols/rows
+ w = self.element.clientWidth;
+ h = self.element.clientHeight;
+ x = Math.round((x / w) * self.cols);
+ y = Math.round((y / h) * self.rows);
+
+ // be sure to avoid sending
+ // bad positions to the program
+ if (x < 0) x = 0;
+ if (x > self.cols) x = self.cols;
+ if (y < 0) y = 0;
+ if (y > self.rows) y = self.rows;
+
+ // xterm sends raw bytes and
+ // starts at 32 (SP) for each.
+ x += 32;
+ y += 32;
+
+ return {
+ x: x,
+ y: y,
+ type: ev.type === wheelEvent
+ ? 'mousewheel'
+ : ev.type
+ };
+ }
+
+ on(el, 'mousedown', function(ev) {
+ if (!self.mouseEvents) return;
+
+ // send the button
+ sendButton(ev);
+
+ // ensure focus
+ self.focus();
+
+ // fix for odd bug
+ //if (self.vt200Mouse && !self.normalMouse) {
+ // XXX This seems to break certain programs.
+ // if (self.vt200Mouse) {
+ // sendButton({ __proto__: ev, type: 'mouseup' });
+ // return cancel(ev);
+ // }
+
+ // bind events
+ if (self.normalMouse) on(self.document, 'mousemove', sendMove);
+
+ // x10 compatibility mode can't send button releases
+ if (!self.x10Mouse) {
+ on(self.document, 'mouseup', function up(ev) {
+ sendButton(ev);
+ if (self.normalMouse) off(self.document, 'mousemove', sendMove);
+ off(self.document, 'mouseup', up);
+ return cancel(ev);
+ });
+ }
+
+ return cancel(ev);
+ });
+
+ //if (self.normalMouse) {
+ // on(self.document, 'mousemove', sendMove);
+ //}
+
+ on(el, wheelEvent, function(ev) {
+ if (!self.mouseEvents) return;
+ if (self.x10Mouse
+ || self.vt300Mouse
+ || self.decLocator) return;
+ sendButton(ev);
+ return cancel(ev);
+ });
+
+ // allow mousewheel scrolling in
+ // the shell for example
+ on(el, wheelEvent, function(ev) {
+ if (self.mouseEvents) return;
+ if (self.applicationKeypad) return;
+ if (ev.type === 'DOMMouseScroll') {
+ self.scrollDisp(ev.detail < 0 ? -5 : 5);
+ } else {
+ self.scrollDisp(ev.wheelDeltaY > 0 ? -5 : 5);
+ }
+ return cancel(ev);
+ });
+};
+
+/**
+ * Destroy Terminal
+ */
+
+Terminal.prototype.close =
+Terminal.prototype.destroySoon =
+Terminal.prototype.destroy = function() {
+ if (this.destroyed) {
+ return;
+ }
+
+ if (this._blink) {
+ clearInterval(this._blink);
+ delete this._blink;
+ }
+
+ this.readable = false;
+ this.writable = false;
+ this.destroyed = true;
+ this._events = {};
+
+ this.handler = function() {};
+ this.write = function() {};
+ this.end = function() {};
+
+ if (this.element.parentNode) {
+ this.element.parentNode.removeChild(this.element);
+ }
+
+ this.emit('end');
+ this.emit('close');
+ this.emit('finish');
+ this.emit('destroy');
+};
+
+/**
+ * Rendering Engine
+ */
+
+// In the screen buffer, each character
+// is stored as a an array with a character
+// and a 32-bit integer.
+// First value: a utf-16 character.
+// Second value:
+// Next 9 bits: background color (0-511).
+// Next 9 bits: foreground color (0-511).
+// Next 14 bits: a mask for misc. flags:
+// 1=bold, 2=underline, 4=blink, 8=inverse, 16=invisible
+
+Terminal.prototype.refresh = function(start, end) {
+ var x
+ , y
+ , i
+ , line
+ , out
+ , ch
+ , width
+ , data
+ , attr
+ , bg
+ , fg
+ , flags
+ , row
+ , parent;
+
+ if (end - start >= this.rows / 2) {
+ parent = this.element.parentNode;
+ if (parent) parent.removeChild(this.element);
+ }
+
+ width = this.cols;
+ y = start;
+
+ if (end >= this.lines.length) {
+ this.log('`end` is too large. Most likely a bad CSR.');
+ end = this.lines.length - 1;
+ }
+
+ for (; y <= end; y++) {
+ row = y + this.ydisp;
+
+ line = this.lines[row];
+ out = '';
+
+ if (y === this.y
+ && this.cursorState
+ && (this.ydisp === this.ybase || this.selectMode)
+ && !this.cursorHidden) {
+ x = this.x;
+ } else {
+ x = -1;
+ }
+
+ attr = this.defAttr;
+ i = 0;
+
+ for (; i < width; i++) {
+ data = line[i][0];
+ ch = line[i][1];
+
+ if (i === x) data = -1;
+
+ if (data !== attr) {
+ if (attr !== this.defAttr) {
+ out += '</span>';
+ }
+ if (data !== this.defAttr) {
+ if (data === -1) {
+ out += '<span class="reverse-video terminal-cursor">';
+ } else {
+ out += '<span style="';
+
+ bg = data & 0x1ff;
+ fg = (data >> 9) & 0x1ff;
+ flags = data >> 18;
+
+ // bold
+ if (flags & 1) {
+ if (!Terminal.brokenBold) {
+ out += 'font-weight:bold;';
+ }
+ // See: XTerm*boldColors
+ if (fg < 8) fg += 8;
+ }
+
+ // underline
+ if (flags & 2) {
+ out += 'text-decoration:underline;';
+ }
+
+ // blink
+ if (flags & 4) {
+ if (flags & 2) {
+ out = out.slice(0, -1);
+ out += ' blink;';
+ } else {
+ out += 'text-decoration:blink;';
+ }
+ }
+
+ // inverse
+ if (flags & 8) {
+ bg = (data >> 9) & 0x1ff;
+ fg = data & 0x1ff;
+ // Should inverse just be before the
+ // above boldColors effect instead?
+ if ((flags & 1) && fg < 8) fg += 8;
+ }
+
+ // invisible
+ if (flags & 16) {
+ out += 'visibility:hidden;';
+ }
+
+ // out += '" class="'
+ // + 'term-bg-color-' + bg
+ // + ' '
+ // + 'term-fg-color-' + fg
+ // + '">';
+
+ if (bg !== 256) {
+ out += 'background-color:'
+ + this.colors[bg]
+ + ';';
+ }
+
+ if (fg !== 257) {
+ out += 'color:'
+ + this.colors[fg]
+ + ';';
+ }
+
+ out += '">';
+ }
+ }
+ }
+
+ switch (ch) {
+ case '&':
+ out += '&';
+ break;
+ case '<':
+ out += '<';
+ break;
+ case '>':
+ out += '>';
+ break;
+ default:
+ if (ch <= ' ') {
+ out += ' ';
+ } else {
+ if (isWide(ch)) i++;
+ out += ch;
+ }
+ break;
+ }
+
+ attr = data;
+ }
+
+ if (attr !== this.defAttr) {
+ out += '</span>';
+ }
+
+ this.children[y].innerHTML = out;
+ }
+
+ if (parent) parent.appendChild(this.element);
+};
+
+Terminal.prototype._cursorBlink = function() {
+ if (Terminal.focus !== this) return;
+ this.cursorState ^= 1;
+ this.refresh(this.y, this.y);
+};
+
+Terminal.prototype.showCursor = function() {
+ if (!this.cursorState) {
+ this.cursorState = 1;
+ this.refresh(this.y, this.y);
+ } else {
+ // Temporarily disabled:
+ // this.refreshBlink();
+ }
+};
+
+Terminal.prototype.startBlink = function() {
+ if (!this.cursorBlink) return;
+ var self = this;
+ this._blinker = function() {
+ self._cursorBlink();
+ };
+ this._blink = setInterval(this._blinker, 500);
+};
+
+Terminal.prototype.refreshBlink = function() {
+ if (!this.cursorBlink || !this._blink) return;
+ clearInterval(this._blink);
+ this._blink = setInterval(this._blinker, 500);
+};
+
+Terminal.prototype.scroll = function() {
+ var row;
+
+ if (++this.ybase === this.scrollback) {
+ this.ybase = this.ybase / 2 | 0;
+ this.lines = this.lines.slice(-(this.ybase + this.rows) + 1);
+ }
+
+ this.ydisp = this.ybase;
+
+ // last line
+ row = this.ybase + this.rows - 1;
+
+ // subtract the bottom scroll region
+ row -= this.rows - 1 - this.scrollBottom;
+
+ if (row === this.lines.length) {
+ // potential optimization:
+ // pushing is faster than splicing
+ // when they amount to the same
+ // behavior.
+ this.lines.push(this.blankLine());
+ } else {
+ // add our new line
+ this.lines.splice(row, 0, this.blankLine());
+ }
+
+ if (this.scrollTop !== 0) {
+ if (this.ybase !== 0) {
+ this.ybase--;
+ this.ydisp = this.ybase;
+ }
+ this.lines.splice(this.ybase + this.scrollTop, 1);
+ }
+
+ // this.maxRange();
+ this.updateRange(this.scrollTop);
+ this.updateRange(this.scrollBottom);
+};
+
+Terminal.prototype.scrollDisp = function(disp) {
+ this.ydisp += disp;
+
+ if (this.ydisp > this.ybase) {
+ this.ydisp = this.ybase;
+ } else if (this.ydisp < 0) {
+ this.ydisp = 0;
+ }
+
+ this.refresh(0, this.rows - 1);
+};
+
+Terminal.prototype.write = function(data) {
+ var l = data.length
+ , i = 0
+ , j
+ , cs
+ , ch;
+
+ this.refreshStart = this.y;
+ this.refreshEnd = this.y;
+
+ if (this.ybase !== this.ydisp) {
+ this.ydisp = this.ybase;
+ this.maxRange();
+ }
+
+ // this.log(JSON.stringify(data.replace(/\x1b/g, '^[')));
+
+ for (; i < l; i++, this.lch = ch) {
+ ch = data[i];
+ switch (this.state) {
+ case normal:
+ switch (ch) {
+ // '\0'
+ // case '\0':
+ // case '\200':
+ // break;
+
+ // '\a'
+ case '\x07':
+ this.bell();
+ break;
+
+ // '\n', '\v', '\f'
+ case '\n':
+ case '\x0b':
+ case '\x0c':
+ if (this.convertEol) {
+ this.x = 0;
+ }
+ // TODO: Implement eat_newline_glitch.
+ // if (this.realX >= this.cols) break;
+ // this.realX = 0;
+ this.y++;
+ if (this.y > this.scrollBottom) {
+ this.y--;
+ this.scroll();
+ }
+ break;
+
+ // '\r'
+ case '\r':
+ this.x = 0;
+ break;
+
+ // '\b'
+ case '\x08':
+ if (this.x > 0) {
+ this.x--;
+ }
+ break;
+
+ // '\t'
+ case '\t':
+ this.x = this.nextStop();
+ break;
+
+ // shift out
+ case '\x0e':
+ this.setgLevel(1);
+ break;
+
+ // shift in
+ case '\x0f':
+ this.setgLevel(0);
+ break;
+
+ // '\e'
+ case '\x1b':
+ this.state = escaped;
+ break;
+
+ default:
+ // ' '
+ if (ch >= ' ') {
+ if (this.charset && this.charset[ch]) {
+ ch = this.charset[ch];
+ }
+
+ if (this.x >= this.cols) {
+ this.x = 0;
+ this.y++;
+ if (this.y > this.scrollBottom) {
+ this.y--;
+ this.scroll();
+ }
+ }
+
+ this.lines[this.y + this.ybase][this.x] = [this.curAttr, ch];
+ this.x++;
+ this.updateRange(this.y);
+
+ if (isWide(ch)) {
+ j = this.y + this.ybase;
+ if (this.cols < 2 || this.x >= this.cols) {
+ this.lines[j][this.x - 1] = [this.curAttr, ' '];
+ break;
+ }
+ this.lines[j][this.x] = [this.curAttr, ' '];
+ this.x++;
+ }
+ }
+ break;
+ }
+ break;
+ case escaped:
+ switch (ch) {
+ // ESC [ Control Sequence Introducer ( CSI is 0x9b).
+ case '[':
+ this.params = [];
+ this.currentParam = 0;
+ this.state = csi;
+ break;
+
+ // ESC ] Operating System Command ( OSC is 0x9d).
+ case ']':
+ this.params = [];
+ this.currentParam = 0;
+ this.state = osc;
+ break;
+
+ // ESC P Device Control String ( DCS is 0x90).
+ case 'P':
+ this.params = [];
+ this.prefix = '';
+ this.currentParam = '';
+ this.state = dcs;
+ break;
+
+ // ESC _ Application Program Command ( APC is 0x9f).
+ case '_':
+ this.state = ignore;
+ break;
+
+ // ESC ^ Privacy Message ( PM is 0x9e).
+ case '^':
+ this.state = ignore;
+ break;
+
+ // ESC c Full Reset (RIS).
+ case 'c':
+ this.reset();
+ break;
+
+ // ESC E Next Line ( NEL is 0x85).
+ // ESC D Index ( IND is 0x84).
+ case 'E':
+ this.x = 0;
+ ;
+ case 'D':
+ this.index();
+ break;
+
+ // ESC M Reverse Index ( RI is 0x8d).
+ case 'M':
+ this.reverseIndex();
+ break;
+
+ // ESC % Select default/utf-8 character set.
+ // @ = default, G = utf-8
+ case '%':
+ //this.charset = null;
+ this.setgLevel(0);
+ this.setgCharset(0, Terminal.charsets.US);
+ this.state = normal;
+ i++;
+ break;
+
+ // ESC (,),*,+,-,. Designate G0-G2 Character Set.
+ case '(': // <-- this seems to get all the attention
+ case ')':
+ case '*':
+ case '+':
+ case '-':
+ case '.':
+ switch (ch) {
+ case '(':
+ this.gcharset = 0;
+ break;
+ case ')':
+ this.gcharset = 1;
+ break;
+ case '*':
+ this.gcharset = 2;
+ break;
+ case '+':
+ this.gcharset = 3;
+ break;
+ case '-':
+ this.gcharset = 1;
+ break;
+ case '.':
+ this.gcharset = 2;
+ break;
+ }
+ this.state = charset;
+ break;
+
+ // Designate G3 Character Set (VT300).
+ // A = ISO Latin-1 Supplemental.
+ // Not implemented.
+ case '/':
+ this.gcharset = 3;
+ this.state = charset;
+ i--;
+ break;
+
+ // ESC N
+ // Single Shift Select of G2 Character Set
+ // ( SS2 is 0x8e). This affects next character only.
+ case 'N':
+ break;
+ // ESC O
+ // Single Shift Select of G3 Character Set
+ // ( SS3 is 0x8f). This affects next character only.
+ case 'O':
+ break;
+ // ESC n
+ // Invoke the G2 Character Set as GL (LS2).
+ case 'n':
+ this.setgLevel(2);
+ break;
+ // ESC o
+ // Invoke the G3 Character Set as GL (LS3).
+ case 'o':
+ this.setgLevel(3);
+ break;
+ // ESC |
+ // Invoke the G3 Character Set as GR (LS3R).
+ case '|':
+ this.setgLevel(3);
+ break;
+ // ESC }
+ // Invoke the G2 Character Set as GR (LS2R).
+ case '}':
+ this.setgLevel(2);
+ break;
+ // ESC ~
+ // Invoke the G1 Character Set as GR (LS1R).
+ case '~':
+ this.setgLevel(1);
+ break;
+
+ // ESC 7 Save Cursor (DECSC).
+ case '7':
+ this.saveCursor();
+ this.state = normal;
+ break;
+
+ // ESC 8 Restore Cursor (DECRC).
+ case '8':
+ this.restoreCursor();
+ this.state = normal;
+ break;
+
+ // ESC # 3 DEC line height/width
+ case '#':
+ this.state = normal;
+ i++;
+ break;
+
+ // ESC H Tab Set (HTS is 0x88).
+ case 'H':
+ this.tabSet();
+ break;
+
+ // ESC = Application Keypad (DECPAM).
+ case '=':
+ this.log('Serial port requested application keypad.');
+ this.applicationKeypad = true;
+ this.state = normal;
+ break;
+
+ // ESC > Normal Keypad (DECPNM).
+ case '>':
+ this.log('Switching back to normal keypad.');
+ this.applicationKeypad = false;
+ this.state = normal;
+ break;
+
+ default:
+ this.state = normal;
+ this.error('Unknown ESC control: %s.', ch);
+ break;
+ }
+ break;
+
+ case charset:
+ switch (ch) {
+ case '0': // DEC Special Character and Line Drawing Set.
+ cs = Terminal.charsets.SCLD;
+ break;
+ case 'A': // UK
+ cs = Terminal.charsets.UK;
+ break;
+ case 'B': // United States (USASCII).
+ cs = Terminal.charsets.US;
+ break;
+ case '4': // Dutch
+ cs = Terminal.charsets.Dutch;
+ break;
+ case 'C': // Finnish
+ case '5':
+ cs = Terminal.charsets.Finnish;
+ break;
+ case 'R': // French
+ cs = Terminal.charsets.French;
+ break;
+ case 'Q': // FrenchCanadian
+ cs = Terminal.charsets.FrenchCanadian;
+ break;
+ case 'K': // German
+ cs = Terminal.charsets.German;
+ break;
+ case 'Y': // Italian
+ cs = Terminal.charsets.Italian;
+ break;
+ case 'E': // NorwegianDanish
+ case '6':
+ cs = Terminal.charsets.NorwegianDanish;
+ break;
+ case 'Z': // Spanish
+ cs = Terminal.charsets.Spanish;
+ break;
+ case 'H': // Swedish
+ case '7':
+ cs = Terminal.charsets.Swedish;
+ break;
+ case '=': // Swiss
+ cs = Terminal.charsets.Swiss;
+ break;
+ case '/': // ISOLatin (actually /A)
+ cs = Terminal.charsets.ISOLatin;
+ i++;
+ break;
+ default: // Default
+ cs = Terminal.charsets.US;
+ break;
+ }
+ this.setgCharset(this.gcharset, cs);
+ this.gcharset = null;
+ this.state = normal;
+ break;
+
+ case osc:
+ // OSC Ps ; Pt ST
+ // OSC Ps ; Pt BEL
+ // Set Text Parameters.
+ if ((this.lch === '\x1b' && ch === '\\') || ch === '\x07') {
+ if (this.lch === '\x1b') {
+ if (typeof this.currentParam === 'string') {
+ this.currentParam = this.currentParam.slice(0, -1);
+ } else if (typeof this.currentParam == 'number') {
+ this.currentParam = (this.currentParam - ('\x1b'.charCodeAt(0) - 48)) / 10;
+ }
+ }
+
+ this.params.push(this.currentParam);
+
+ switch (this.params[0]) {
+ case 0:
+ case 1:
+ case 2:
+ if (this.params[1]) {
+ this.title = this.params[1];
+ this.handleTitle(this.title);
+ }
+ break;
+ case 3:
+ // set X property
+ break;
+ case 4:
+ case 5:
+ // change dynamic colors
+ break;
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ // change dynamic ui colors
+ break;
+ case 46:
+ // change log file
+ break;
+ case 50:
+ // dynamic font
+ break;
+ case 51:
+ // emacs shell
+ break;
+ case 52:
+ // manipulate selection data
+ break;
+ case 104:
+ case 105:
+ case 110:
+ case 111:
+ case 112:
+ case 113:
+ case 114:
+ case 115:
+ case 116:
+ case 117:
+ case 118:
+ // reset colors
+ break;
+ }
+
+ this.params = [];
+ this.currentParam = 0;
+ this.state = normal;
+ } else {
+ if (!this.params.length) {
+ if (ch >= '0' && ch <= '9') {
+ this.currentParam =
+ this.currentParam * 10 + ch.charCodeAt(0) - 48;
+ } else if (ch === ';') {
+ this.params.push(this.currentParam);
+ this.currentParam = '';
+ }
+ } else {
+ this.currentParam += ch;
+ }
+ }
+ break;
+
+ case csi:
+ // '?', '>', '!'
+ if (ch === '?' || ch === '>' || ch === '!') {
+ this.prefix = ch;
+ break;
+ }
+
+ // 0 - 9
+ if (ch >= '0' && ch <= '9') {
+ this.currentParam = this.currentParam * 10 + ch.charCodeAt(0) - 48;
+ break;
+ }
+
+ // '$', '"', ' ', '\''
+ if (ch === '$' || ch === '"' || ch === ' ' || ch === '\'') {
+ this.postfix = ch;
+ break;
+ }
+
+ this.params.push(this.currentParam);
+ this.currentParam = 0;
+
+ // ';'
+ if (ch === ';') break;
+
+ this.state = normal;
+
+ switch (ch) {
+ // CSI Ps A
+ // Cursor Up Ps Times (default = 1) (CUU).
+ case 'A':
+ this.cursorUp(this.params);
+ break;
+
+ // CSI Ps B
+ // Cursor Down Ps Times (default = 1) (CUD).
+ case 'B':
+ this.cursorDown(this.params);
+ break;
+
+ // CSI Ps C
+ // Cursor Forward Ps Times (default = 1) (CUF).
+ case 'C':
+ this.cursorForward(this.params);
+ break;
+
+ // CSI Ps D
+ // Cursor Backward Ps Times (default = 1) (CUB).
+ case 'D':
+ this.cursorBackward(this.params);
+ break;
+
+ // CSI Ps ; Ps H
+ // Cursor Position [row;column] (default = [1,1]) (CUP).
+ case 'H':
+ this.cursorPos(this.params);
+ break;
+
+ // CSI Ps J Erase in Display (ED).
+ case 'J':
+ this.eraseInDisplay(this.params);
+ break;
+
+ // CSI Ps K Erase in Line (EL).
+ case 'K':
+ this.eraseInLine(this.params);
+ break;
+
+ // CSI Pm m Character Attributes (SGR).
+ case 'm':
+ if (!this.prefix) {
+ this.charAttributes(this.params);
+ }
+ break;
+
+ // CSI Ps n Device Status Report (DSR).
+ case 'n':
+ if (!this.prefix) {
+ this.deviceStatus(this.params);
+ }
+ break;
+
+ /**
+ * Additions
+ */
+
+ // CSI Ps @
+ // Insert Ps (Blank) Character(s) (default = 1) (ICH).
+ case '@':
+ this.insertChars(this.params);
+ break;
+
+ // CSI Ps E
+ // Cursor Next Line Ps Times (default = 1) (CNL).
+ case 'E':
+ this.cursorNextLine(this.params);
+ break;
+
+ // CSI Ps F
+ // Cursor Preceding Line Ps Times (default = 1) (CNL).
+ case 'F':
+ this.cursorPrecedingLine(this.params);
+ break;
+
+ // CSI Ps G
+ // Cursor Character Absolute [column] (default = [row,1]) (CHA).
+ case 'G':
+ this.cursorCharAbsolute(this.params);
+ break;
+
+ // CSI Ps L
+ // Insert Ps Line(s) (default = 1) (IL).
+ case 'L':
+ this.insertLines(this.params);
+ break;
+
+ // CSI Ps M
+ // Delete Ps Line(s) (default = 1) (DL).
+ case 'M':
+ this.deleteLines(this.params);
+ break;
+
+ // CSI Ps P
+ // Delete Ps Character(s) (default = 1) (DCH).
+ case 'P':
+ this.deleteChars(this.params);
+ break;
+
+ // CSI Ps X
+ // Erase Ps Character(s) (default = 1) (ECH).
+ case 'X':
+ this.eraseChars(this.params);
+ break;
+
+ // CSI Pm ` Character Position Absolute
+ // [column] (default = [row,1]) (HPA).
+ case '`':
+ this.charPosAbsolute(this.params);
+ break;
+
+ // 141 61 a * HPR -
+ // Horizontal Position Relative
+ case 'a':
+ this.HPositionRelative(this.params);
+ break;
+
+ // CSI P s c
+ // Send Device Attributes (Primary DA).
+ // CSI > P s c
+ // Send Device Attributes (Secondary DA)
+ case 'c':
+ this.sendDeviceAttributes(this.params);
+ break;
+
+ // CSI Pm d
+ // Line Position Absolute [row] (default = [1,column]) (VPA).
+ case 'd':
+ this.linePosAbsolute(this.params);
+ break;
+
+ // 145 65 e * VPR - Vertical Position Relative
+ case 'e':
+ this.VPositionRelative(this.params);
+ break;
+
+ // CSI Ps ; Ps f
+ // Horizontal and Vertical Position [row;column] (default =
+ // [1,1]) (HVP).
+ case 'f':
+ this.HVPosition(this.params);
+ break;
+
+ // CSI Pm h Set Mode (SM).
+ // CSI ? Pm h - mouse escape codes, cursor escape codes
+ case 'h':
+ this.setMode(this.params);
+ break;
+
+ // CSI Pm l Reset Mode (RM).
+ // CSI ? Pm l
+ case 'l':
+ this.resetMode(this.params);
+ break;
+
+ // CSI Ps ; Ps r
+ // Set Scrolling Region [top;bottom] (default = full size of win-
+ // dow) (DECSTBM).
+ // CSI ? Pm r
+ case 'r':
+ this.setScrollRegion(this.params);
+ break;
+
+ // CSI s
+ // Save cursor (ANSI.SYS).
+ case 's':
+ this.saveCursor(this.params);
+ break;
+
+ // CSI u
+ // Restore cursor (ANSI.SYS).
+ case 'u':
+ this.restoreCursor(this.params);
+ break;
+
+ /**
+ * Lesser Used
+ */
+
+ // CSI Ps I
+ // Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
+ case 'I':
+ this.cursorForwardTab(this.params);
+ break;
+
+ // CSI Ps S Scroll up Ps lines (default = 1) (SU).
+ case 'S':
+ this.scrollUp(this.params);
+ break;
+
+ // CSI Ps T Scroll down Ps lines (default = 1) (SD).
+ // CSI Ps ; Ps ; Ps ; Ps ; Ps T
+ // CSI > Ps; Ps T
+ case 'T':
+ // if (this.prefix === '>') {
+ // this.resetTitleModes(this.params);
+ // break;
+ // }
+ // if (this.params.length > 2) {
+ // this.initMouseTracking(this.params);
+ // break;
+ // }
+ if (this.params.length < 2 && !this.prefix) {
+ this.scrollDown(this.params);
+ }
+ break;
+
+ // CSI Ps Z
+ // Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
+ case 'Z':
+ this.cursorBackwardTab(this.params);
+ break;
+
+ // CSI Ps b Repeat the preceding graphic character Ps times (REP).
+ case 'b':
+ this.repeatPrecedingCharacter(this.params);
+ break;
+
+ // CSI Ps g Tab Clear (TBC).
+ case 'g':
+ this.tabClear(this.params);
+ break;
+
+ // CSI Pm i Media Copy (MC).
+ // CSI ? Pm i
+ // case 'i':
+ // this.mediaCopy(this.params);
+ // break;
+
+ // CSI Pm m Character Attributes (SGR).
+ // CSI > Ps; Ps m
+ // case 'm': // duplicate
+ // if (this.prefix === '>') {
+ // this.setResources(this.params);
+ // } else {
+ // this.charAttributes(this.params);
+ // }
+ // break;
+
+ // CSI Ps n Device Status Report (DSR).
+ // CSI > Ps n
+ // case 'n': // duplicate
+ // if (this.prefix === '>') {
+ // this.disableModifiers(this.params);
+ // } else {
+ // this.deviceStatus(this.params);
+ // }
+ // break;
+
+ // CSI > Ps p Set pointer mode.
+ // CSI ! p Soft terminal reset (DECSTR).
+ // CSI Ps$ p
+ // Request ANSI mode (DECRQM).
+ // CSI ? Ps$ p
+ // Request DEC private mode (DECRQM).
+ // CSI Ps ; Ps " p
+ case 'p':
+ switch (this.prefix) {
+ // case '>':
+ // this.setPointerMode(this.params);
+ // break;
+ case '!':
+ this.softReset(this.params);
+ break;
+ // case '?':
+ // if (this.postfix === '$') {
+ // this.requestPrivateMode(this.params);
+ // }
+ // break;
+ // default:
+ // if (this.postfix === '"') {
+ // this.setConformanceLevel(this.params);
+ // } else if (this.postfix === '$') {
+ // this.requestAnsiMode(this.params);
+ // }
+ // break;
+ }
+ break;
+
+ // CSI Ps q Load LEDs (DECLL).
+ // CSI Ps SP q
+ // CSI Ps " q
+ // case 'q':
+ // if (this.postfix === ' ') {
+ // this.setCursorStyle(this.params);
+ // break;
+ // }
+ // if (this.postfix === '"') {
+ // this.setCharProtectionAttr(this.params);
+ // break;
+ // }
+ // this.loadLEDs(this.params);
+ // break;
+
+ // CSI Ps ; Ps r
+ // Set Scrolling Region [top;bottom] (default = full size of win-
+ // dow) (DECSTBM).
+ // CSI ? Pm r
+ // CSI Pt; Pl; Pb; Pr; Ps$ r
+ // case 'r': // duplicate
+ // if (this.prefix === '?') {
+ // this.restorePrivateValues(this.params);
+ // } else if (this.postfix === '$') {
+ // this.setAttrInRectangle(this.params);
+ // } else {
+ // this.setScrollRegion(this.params);
+ // }
+ // break;
+
+ // CSI s Save cursor (ANSI.SYS).
+ // CSI ? Pm s
+ // case 's': // duplicate
+ // if (this.prefix === '?') {
+ // this.savePrivateValues(this.params);
+ // } else {
+ // this.saveCursor(this.params);
+ // }
+ // break;
+
+ // CSI Ps ; Ps ; Ps t
+ // CSI Pt; Pl; Pb; Pr; Ps$ t
+ // CSI > Ps; Ps t
+ // CSI Ps SP t
+ // case 't':
+ // if (this.postfix === '$') {
+ // this.reverseAttrInRectangle(this.params);
+ // } else if (this.postfix === ' ') {
+ // this.setWarningBellVolume(this.params);
+ // } else {
+ // if (this.prefix === '>') {
+ // this.setTitleModeFeature(this.params);
+ // } else {
+ // this.manipulateWindow(this.params);
+ // }
+ // }
+ // break;
+
+ // CSI u Restore cursor (ANSI.SYS).
+ // CSI Ps SP u
+ // case 'u': // duplicate
+ // if (this.postfix === ' ') {
+ // this.setMarginBellVolume(this.params);
+ // } else {
+ // this.restoreCursor(this.params);
+ // }
+ // break;
+
+ // CSI Pt; Pl; Pb; Pr; Pp; Pt; Pl; Pp$ v
+ // case 'v':
+ // if (this.postfix === '$') {
+ // this.copyRectagle(this.params);
+ // }
+ // break;
+
+ // CSI Pt ; Pl ; Pb ; Pr ' w
+ // case 'w':
+ // if (this.postfix === '\'') {
+ // this.enableFilterRectangle(this.params);
+ // }
+ // break;
+
+ // CSI Ps x Request Terminal Parameters (DECREQTPARM).
+ // CSI Ps x Select Attribute Change Extent (DECSACE).
+ // CSI Pc; Pt; Pl; Pb; Pr$ x
+ // case 'x':
+ // if (this.postfix === '$') {
+ // this.fillRectangle(this.params);
+ // } else {
+ // this.requestParameters(this.params);
+ // //this.__(this.params);
+ // }
+ // break;
+
+ // CSI Ps ; Pu ' z
+ // CSI Pt; Pl; Pb; Pr$ z
+ // case 'z':
+ // if (this.postfix === '\'') {
+ // this.enableLocatorReporting(this.params);
+ // } else if (this.postfix === '$') {
+ // this.eraseRectangle(this.params);
+ // }
+ // break;
+
+ // CSI Pm ' {
+ // CSI Pt; Pl; Pb; Pr$ {
+ // case '{':
+ // if (this.postfix === '\'') {
+ // this.setLocatorEvents(this.params);
+ // } else if (this.postfix === '$') {
+ // this.selectiveEraseRectangle(this.params);
+ // }
+ // break;
+
+ // CSI Ps ' |
+ // case '|':
+ // if (this.postfix === '\'') {
+ // this.requestLocatorPosition(this.params);
+ // }
+ // break;
+
+ // CSI P m SP }
+ // Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
+ // case '}':
+ // if (this.postfix === ' ') {
+ // this.insertColumns(this.params);
+ // }
+ // break;
+
+ // CSI P m SP ~
+ // Delete P s Column(s) (default = 1) (DECDC), VT420 and up
+ // case '~':
+ // if (this.postfix === ' ') {
+ // this.deleteColumns(this.params);
+ // }
+ // break;
+
+ default:
+ this.error('Unknown CSI code: %s.', ch);
+ break;
+ }
+
+ this.prefix = '';
+ this.postfix = '';
+ break;
+
+ case dcs:
+ if ((this.lch === '\x1b' && ch === '\\') || ch === '\x07') {
+ // Workarounds:
+ if (this.prefix === 'tmux;\x1b') {
+ // `DCS tmux; Pt ST` may contain a Pt with an ST
+ // XXX Does tmux work this way?
+ // if (this.lch === '\x1b' & data[i + 1] === '\x1b' && data[i + 2] === '\\') {
+ // this.currentParam += ch;
+ // continue;
+ // }
+ // Tmux only accepts ST, not BEL:
+ if (ch === '\x07') {
+ this.currentParam += ch;
+ continue;
+ }
+ }
+
+ if (this.lch === '\x1b') {
+ if (typeof this.currentParam === 'string') {
+ this.currentParam = this.currentParam.slice(0, -1);
+ } else if (typeof this.currentParam == 'number') {
+ this.currentParam = (this.currentParam - ('\x1b'.charCodeAt(0) - 48)) / 10;
+ }
+ }
+
+ this.params.push(this.currentParam);
+
+ var pt = this.params[this.params.length - 1];
+
+ switch (this.prefix) {
+ // User-Defined Keys (DECUDK).
+ // DCS Ps; Ps| Pt ST
+ case UDK:
+ this.emit('udk', {
+ clearAll: this.params[0] === 0,
+ eraseBelow: this.params[0] === 1,
+ lockKeys: this.params[1] === 0,
+ dontLockKeys: this.params[1] === 1,
+ keyList: (this.params[2] + '').split(';').map(function(part) {
+ part = part.split('/');
+ return {
+ keyCode: part[0],
+ hexKeyValue: part[1]
+ };
+ })
+ });
+ break;
+
+ // Request Status String (DECRQSS).
+ // DCS $ q Pt ST
+ // test: echo -e '\eP$q"p\e\\'
+ case '$q':
+ var valid = 0;
+
+ switch (pt) {
+ // DECSCA
+ // CSI Ps " q
+ case '"q':
+ pt = '0"q';
+ valid = 1;
+ break;
+
+ // DECSCL
+ // CSI Ps ; Ps " p
+ case '"p':
+ pt = '61;0"p';
+ valid = 1;
+ break;
+
+ // DECSTBM
+ // CSI Ps ; Ps r
+ case 'r':
+ pt = ''
+ + (this.scrollTop + 1)
+ + ';'
+ + (this.scrollBottom + 1)
+ + 'r';
+ valid = 1;
+ break;
+
+ // SGR
+ // CSI Pm m
+ case 'm':
+ // TODO: Parse this.curAttr here.
+ // pt = '0m';
+ // valid = 1;
+ valid = 0; // Not implemented.
+ break;
+
+ default:
+ this.error('Unknown DCS Pt: %s.', pt);
+ valid = 0; // unimplemented
+ break;
+ }
+
+ this.send('\x1bP' + valid + '$r' + pt + '\x1b\\');
+ break;
+
+ // Set Termcap/Terminfo Data (xterm, experimental).
+ // DCS + p Pt ST
+ case '+p':
+ this.emit('set terminfo', {
+ name: this.params[0]
+ });
+ break;
+
+ // Request Termcap/Terminfo String (xterm, experimental)
+ // Regular xterm does not even respond to this sequence.
+ // This can cause a small glitch in vim.
+ // DCS + q Pt ST
+ // test: echo -ne '\eP+q6b64\e\\'
+ case '+q':
+ var valid = false;
+ this.send('\x1bP' + +valid + '+r' + pt + '\x1b\\');
+ break;
+
+ // Implement tmux sequence forwarding is
+ // someone uses term.js for a multiplexer.
+ // DCS tmux; ESC Pt ST
+ case 'tmux;\x1b':
+ this.emit('passthrough', pt);
+ break;
+
+ default:
+ this.error('Unknown DCS prefix: %s.', pt);
+ break;
+ }
+
+ this.currentParam = 0;
+ this.prefix = '';
+ this.state = normal;
+ } else {
+ this.currentParam += ch;
+ if (!this.prefix) {
+ if (/^\d*;\d*\|/.test(this.currentParam)) {
+ this.prefix = UDK;
+ this.params = this.currentParam.split(/[;|]/).map(function(n) {
+ if (!n.length) return 0;
+ return +n;
+ }).slice(0, -1);
+ this.currentParam = '';
+ } else if (/^[$+][a-zA-Z]/.test(this.currentParam)
+ || /^\w+;\x1b/.test(this.currentParam)) {
+ this.prefix = this.currentParam;
+ this.currentParam = '';
+ }
+ }
+ }
+ break;
+
+ case ignore:
+ // For PM and APC.
+ if ((this.lch === '\x1b' && ch === '\\') || ch === '\x07') {
+ this.state = normal;
+ }
+ break;
+ }
+ }
+
+ this.updateRange(this.y);
+ this.refresh(this.refreshStart, this.refreshEnd);
+
+ return true;
+};
+
+Terminal.prototype.writeln = function(data) {
+ return this.write(data + '\r\n');
+};
+
+Terminal.prototype.end = function(data) {
+ var ret = true;
+ if (data) {
+ ret = this.write(data);
+ }
+ this.destroySoon();
+ return ret;
+};
+
+Terminal.prototype.resume = function() {
+ ;
+};
+
+Terminal.prototype.pause = function() {
+ ;
+};
+
+// Key Resources:
+// https://developer.mozilla.org/en-US/docs/DOM/KeyboardEvent
+Terminal.prototype.keyDown = function(ev) {
+ var self = this
+ , key;
+
+ switch (ev.keyCode) {
+ // backspace
+ case 8:
+ if (ev.altKey) {
+ key = '\x17';
+ break;
+ }
+ if (ev.shiftKey) {
+ key = '\x08'; // ^H
+ break;
+ }
+ key = '\x7f'; // ^?
+ break;
+ // tab
+ case 9:
+ if (ev.shiftKey) {
+ key = '\x1b[Z';
+ break;
+ }
+ key = '\t';
+ break;
+ // return/enter
+ case 13:
+ key = '\r';
+ break;
+ // escape
+ case 27:
+ key = '\x1b';
+ break;
+ // left-arrow
+ case 37:
+ if (this.applicationCursor) {
+ key = '\x1bOD'; // SS3 as ^[O for 7-bit
+ //key = '\x8fD'; // SS3 as 0x8f for 8-bit
+ break;
+ }
+ if (ev.ctrlKey) {
+ key = '\x1b[5D';
+ break;
+ }
+ key = '\x1b[D';
+ break;
+ // right-arrow
+ case 39:
+ if (this.applicationCursor) {
+ key = '\x1bOC';
+ break;
+ }
+ if (ev.ctrlKey) {
+ key = '\x1b[5C';
+ break;
+ }
+ key = '\x1b[C';
+ break;
+ // up-arrow
+ case 38:
+ if (this.applicationCursor) {
+ key = '\x1bOA';
+ break;
+ }
+ if (ev.ctrlKey) {
+ this.scrollDisp(-1);
+ return cancel(ev);
+ } else {
+ key = '\x1b[A';
+ }
+ break;
+ // down-arrow
+ case 40:
+ if (this.applicationCursor) {
+ key = '\x1bOB';
+ break;
+ }
+ if (ev.ctrlKey) {
+ this.scrollDisp(1);
+ return cancel(ev);
+ } else {
+ key = '\x1b[B';
+ }
+ break;
+ // delete
+ case 46:
+ key = '\x1b[3~';
+ break;
+ // insert
+ case 45:
+ key = '\x1b[2~';
+ break;
+ // home
+ case 36:
+ if (this.applicationKeypad) {
+ key = '\x1bOH';
+ break;
+ }
+ key = '\x1bOH';
+ break;
+ // end
+ case 35:
+ if (this.applicationKeypad) {
+ key = '\x1bOF';
+ break;
+ }
+ key = '\x1bOF';
+ break;
+ // page up
+ case 33:
+ if (ev.shiftKey) {
+ this.scrollDisp(-(this.rows - 1));
+ return cancel(ev);
+ } else {
+ key = '\x1b[5~';
+ }
+ break;
+ // page down
+ case 34:
+ if (ev.shiftKey) {
+ this.scrollDisp(this.rows - 1);
+ return cancel(ev);
+ } else {
+ key = '\x1b[6~';
+ }
+ break;
+ // F1
+ case 112:
+ key = '\x1bOP';
+ break;
+ // F2
+ case 113:
+ key = '\x1bOQ';
+ break;
+ // F3
+ case 114:
+ key = '\x1bOR';
+ break;
+ // F4
+ case 115:
+ key = '\x1bOS';
+ break;
+ // F5
+ case 116:
+ key = '\x1b[15~';
+ break;
+ // F6
+ case 117:
+ key = '\x1b[17~';
+ break;
+ // F7
+ case 118:
+ key = '\x1b[18~';
+ break;
+ // F8
+ case 119:
+ key = '\x1b[19~';
+ break;
+ // F9
+ case 120:
+ key = '\x1b[20~';
+ break;
+ // F10
+ case 121:
+ key = '\x1b[21~';
+ break;
+ // F11
+ case 122:
+ key = '\x1b[23~';
+ break;
+ // F12
+ case 123:
+ key = '\x1b[24~';
+ break;
+ default:
+ // a-z and space
+ if (ev.ctrlKey) {
+ if (ev.keyCode >= 65 && ev.keyCode <= 90) {
+ // Ctrl-A
+ if (this.screenKeys) {
+ if (!this.prefixMode && !this.selectMode && ev.keyCode === 65) {
+ this.enterPrefix();
+ return cancel(ev);
+ }
+ }
+ // Ctrl-V
+ if (this.prefixMode && ev.keyCode === 86) {
+ this.leavePrefix();
+ return;
+ }
+ // Ctrl-C
+ if ((this.prefixMode || this.selectMode) && ev.keyCode === 67) {
+ if (this.visualMode) {
+ setTimeout(function() {
+ self.leaveVisual();
+ }, 1);
+ }
+ return;
+ }
+ key = String.fromCharCode(ev.keyCode - 64);
+ } else if (ev.keyCode === 32) {
+ // NUL
+ key = String.fromCharCode(0);
+ } else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
+ // escape, file sep, group sep, record sep, unit sep
+ key = String.fromCharCode(ev.keyCode - 51 + 27);
+ } else if (ev.keyCode === 56) {
+ // delete
+ key = String.fromCharCode(127);
+ } else if (ev.keyCode === 219) {
+ // ^[ - escape
+ key = String.fromCharCode(27);
+ } else if (ev.keyCode === 221) {
+ // ^] - group sep
+ key = String.fromCharCode(29);
+ }
+ } else if (ev.altKey) {
+ if (ev.keyCode >= 65 && ev.keyCode <= 90) {
+ key = '\x1b' + String.fromCharCode(ev.keyCode + 32);
+ } else if (ev.keyCode === 192) {
+ key = '\x1b`';
+ } else if (ev.keyCode >= 48 && ev.keyCode <= 57) {
+ key = '\x1b' + (ev.keyCode - 48);
+ }
+ }
+ break;
+ }
+
+ if (!key) return true;
+
+ if (this.prefixMode) {
+ this.leavePrefix();
+ return cancel(ev);
+ }
+
+ if (this.selectMode) {
+ this.keySelect(ev, key);
+ return cancel(ev);
+ }
+
+ this.emit('keydown', ev);
+ this.emit('key', key, ev);
+
+ this.showCursor();
+ this.handler(key);
+
+ return cancel(ev);
+};
+
+Terminal.prototype.setgLevel = function(g) {
+ this.glevel = g;
+ this.charset = this.charsets[g];
+};
+
+Terminal.prototype.setgCharset = function(g, charset) {
+ this.charsets[g] = charset;
+ if (this.glevel === g) {
+ this.charset = charset;
+ }
+};
+
+Terminal.prototype.keyPress = function(ev) {
+ var key;
+
+ cancel(ev);
+
+ if (ev.charCode) {
+ key = ev.charCode;
+ } else if (ev.which == null) {
+ key = ev.keyCode;
+ } else if (ev.which !== 0 && ev.charCode !== 0) {
+ key = ev.which;
+ } else {
+ return false;
+ }
+
+ if (!key || ev.ctrlKey || ev.altKey || ev.metaKey) return false;
+
+ key = String.fromCharCode(key);
+
+ if (this.prefixMode) {
+ this.leavePrefix();
+ this.keyPrefix(ev, key);
+ return false;
+ }
+
+ if (this.selectMode) {
+ this.keySelect(ev, key);
+ return false;
+ }
+
+ this.emit('keypress', key, ev);
+ this.emit('key', key, ev);
+
+ this.showCursor();
+ this.handler(key);
+
+ return false;
+};
+
+Terminal.prototype.send = function(data) {
+ var self = this;
+
+ if (!this.queue) {
+ setTimeout(function() {
+ self.handler(self.queue);
+ self.queue = '';
+ }, 1);
+ }
+
+ this.queue += data;
+};
+
+Terminal.prototype.bell = function() {
+ this.emit('bell');
+ if (!this.visualBell) return;
+ var self = this;
+ this.element.style.borderColor = 'white';
+ setTimeout(function() {
+ self.element.style.borderColor = '';
+ }, 10);
+ if (this.popOnBell) this.focus();
+};
+
+Terminal.prototype.log = function() {
+ if (!this.debug) return;
+ if (!this.context.console || !this.context.console.log) return;
+ var args = Array.prototype.slice.call(arguments);
+ this.context.console.log.apply(this.context.console, args);
+};
+
+Terminal.prototype.error = function() {
+ if (!this.debug) return;
+ if (!this.context.console || !this.context.console.error) return;
+ var args = Array.prototype.slice.call(arguments);
+ this.context.console.error.apply(this.context.console, args);
+};
+
+Terminal.prototype.resize = function(x, y) {
+ var line
+ , el
+ , i
+ , j
+ , ch;
+
+ if (x < 1) x = 1;
+ if (y < 1) y = 1;
+
+ // resize cols
+ j = this.cols;
+ if (j < x) {
+ ch = [this.defAttr, ' ']; // does xterm use the default attr?
+ i = this.lines.length;
+ while (i--) {
+ while (this.lines[i].length < x) {
+ this.lines[i].push(ch);
+ }
+ }
+ } else if (j > x) {
+ i = this.lines.length;
+ while (i--) {
+ while (this.lines[i].length > x) {
+ this.lines[i].pop();
+ }
+ }
+ }
+ this.setupStops(j);
+ this.cols = x;
+ this.columns = x;
+
+ // resize rows
+ j = this.rows;
+ if (j < y) {
+ el = this.element;
+ while (j++ < y) {
+ if (this.lines.length < y + this.ybase) {
+ this.lines.push(this.blankLine());
+ }
+ if (this.children.length < y) {
+ line = this.document.createElement('div');
+ el.appendChild(line);
+ this.children.push(line);
+ }
+ }
+ } else if (j > y) {
+ while (j-- > y) {
+ if (this.lines.length > y + this.ybase) {
+ this.lines.pop();
+ }
+ if (this.children.length > y) {
+ el = this.children.pop();
+ if (!el) continue;
+ el.parentNode.removeChild(el);
+ }
+ }
+ }
+ this.rows = y;
+
+ // make sure the cursor stays on screen
+ if (this.y >= y) this.y = y - 1;
+ if (this.x >= x) this.x = x - 1;
+
+ this.scrollTop = 0;
+ this.scrollBottom = y - 1;
+
+ this.refresh(0, this.rows - 1);
+
+ // it's a real nightmare trying
+ // to resize the original
+ // screen buffer. just set it
+ // to null for now.
+ this.normal = null;
+
+ // Act as though we are a node TTY stream:
+ this.emit('resize');
+};
+
+Terminal.prototype.updateRange = function(y) {
+ if (y < this.refreshStart) this.refreshStart = y;
+ if (y > this.refreshEnd) this.refreshEnd = y;
+ // if (y > this.refreshEnd) {
+ // this.refreshEnd = y;
+ // if (y > this.rows - 1) {
+ // this.refreshEnd = this.rows - 1;
+ // }
+ // }
+};
+
+Terminal.prototype.maxRange = function() {
+ this.refreshStart = 0;
+ this.refreshEnd = this.rows - 1;
+};
+
+Terminal.prototype.setupStops = function(i) {
+ if (i != null) {
+ if (!this.tabs[i]) {
+ i = this.prevStop(i);
+ }
+ } else {
+ this.tabs = {};
+ i = 0;
+ }
+
+ for (; i < this.cols; i += 8) {
+ this.tabs[i] = true;
+ }
+};
+
+Terminal.prototype.prevStop = function(x) {
+ if (x == null) x = this.x;
+ while (!this.tabs[--x] && x > 0);
+ return x >= this.cols
+ ? this.cols - 1
+ : x < 0 ? 0 : x;
+};
+
+Terminal.prototype.nextStop = function(x) {
+ if (x == null) x = this.x;
+ while (!this.tabs[++x] && x < this.cols);
+ return x >= this.cols
+ ? this.cols - 1
+ : x < 0 ? 0 : x;
+};
+
+// back_color_erase feature for xterm.
+Terminal.prototype.eraseAttr = function() {
+ // if (this.is('screen')) return this.defAttr;
+ return (this.defAttr & ~0x1ff) | (this.curAttr & 0x1ff);
+};
+
+Terminal.prototype.eraseRight = function(x, y) {
+ var line = this.lines[this.ybase + y]
+ , ch = [this.eraseAttr(), ' ']; // xterm
+
+
+ for (; x < this.cols; x++) {
+ line[x] = ch;
+ }
+
+ this.updateRange(y);
+};
+
+Terminal.prototype.eraseLeft = function(x, y) {
+ var line = this.lines[this.ybase + y]
+ , ch = [this.eraseAttr(), ' ']; // xterm
+
+ x++;
+ while (x--) line[x] = ch;
+
+ this.updateRange(y);
+};
+
+Terminal.prototype.eraseLine = function(y) {
+ this.eraseRight(0, y);
+};
+
+Terminal.prototype.blankLine = function(cur) {
+ var attr = cur
+ ? this.eraseAttr()
+ : this.defAttr;
+
+ var ch = [attr, ' ']
+ , line = []
+ , i = 0;
+
+ for (; i < this.cols; i++) {
+ line[i] = ch;
+ }
+
+ return line;
+};
+
+Terminal.prototype.ch = function(cur) {
+ return cur
+ ? [this.eraseAttr(), ' ']
+ : [this.defAttr, ' '];
+};
+
+Terminal.prototype.is = function(term) {
+ var name = this.termName;
+ return (name + '').indexOf(term) === 0;
+};
+
+Terminal.prototype.handler = function(data) {
+ this.emit('data', data);
+};
+
+Terminal.prototype.handleTitle = function(title) {
+ this.emit('title', title);
+};
+
+/**
+ * ESC
+ */
+
+// ESC D Index (IND is 0x84).
+Terminal.prototype.index = function() {
+ this.y++;
+ if (this.y > this.scrollBottom) {
+ this.y--;
+ this.scroll();
+ }
+ this.state = normal;
+};
+
+// ESC M Reverse Index (RI is 0x8d).
+Terminal.prototype.reverseIndex = function() {
+ var j;
+ this.y--;
+ if (this.y < this.scrollTop) {
+ this.y++;
+ // possibly move the code below to term.reverseScroll();
+ // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
+ // blankLine(true) is xterm/linux behavior
+ this.lines.splice(this.y + this.ybase, 0, this.blankLine(true));
+ j = this.rows - 1 - this.scrollBottom;
+ this.lines.splice(this.rows - 1 + this.ybase - j + 1, 1);
+ // this.maxRange();
+ this.updateRange(this.scrollTop);
+ this.updateRange(this.scrollBottom);
+ }
+ this.state = normal;
+};
+
+// ESC c Full Reset (RIS).
+Terminal.prototype.reset = function() {
+ this.options.rows = this.rows;
+ this.options.cols = this.cols;
+ Terminal.call(this, this.options);
+ this.refresh(0, this.rows - 1);
+};
+
+// ESC H Tab Set (HTS is 0x88).
+Terminal.prototype.tabSet = function() {
+ this.tabs[this.x] = true;
+ this.state = normal;
+};
+
+/**
+ * CSI
+ */
+
+// CSI Ps A
+// Cursor Up Ps Times (default = 1) (CUU).
+Terminal.prototype.cursorUp = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y -= param;
+ if (this.y < 0) this.y = 0;
+};
+
+// CSI Ps B
+// Cursor Down Ps Times (default = 1) (CUD).
+Terminal.prototype.cursorDown = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y += param;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ }
+};
+
+// CSI Ps C
+// Cursor Forward Ps Times (default = 1) (CUF).
+Terminal.prototype.cursorForward = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.x += param;
+ if (this.x >= this.cols) {
+ this.x = this.cols - 1;
+ }
+};
+
+// CSI Ps D
+// Cursor Backward Ps Times (default = 1) (CUB).
+Terminal.prototype.cursorBackward = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.x -= param;
+ if (this.x < 0) this.x = 0;
+};
+
+// CSI Ps ; Ps H
+// Cursor Position [row;column] (default = [1,1]) (CUP).
+Terminal.prototype.cursorPos = function(params) {
+ var row, col;
+
+ row = params[0] - 1;
+
+ if (params.length >= 2) {
+ col = params[1] - 1;
+ } else {
+ col = 0;
+ }
+
+ if (row < 0) {
+ row = 0;
+ } else if (row >= this.rows) {
+ row = this.rows - 1;
+ }
+
+ if (col < 0) {
+ col = 0;
+ } else if (col >= this.cols) {
+ col = this.cols - 1;
+ }
+
+ this.x = col;
+ this.y = row;
+};
+
+// CSI Ps J Erase in Display (ED).
+// Ps = 0 -> Erase Below (default).
+// Ps = 1 -> Erase Above.
+// Ps = 2 -> Erase All.
+// Ps = 3 -> Erase Saved Lines (xterm).
+// CSI ? Ps J
+// Erase in Display (DECSED).
+// Ps = 0 -> Selective Erase Below (default).
+// Ps = 1 -> Selective Erase Above.
+// Ps = 2 -> Selective Erase All.
+Terminal.prototype.eraseInDisplay = function(params) {
+ var j;
+ switch (params[0]) {
+ case 0:
+ this.eraseRight(this.x, this.y);
+ j = this.y + 1;
+ for (; j < this.rows; j++) {
+ this.eraseLine(j);
+ }
+ break;
+ case 1:
+ this.eraseLeft(this.x, this.y);
+ j = this.y;
+ while (j--) {
+ this.eraseLine(j);
+ }
+ break;
+ case 2:
+ j = this.rows;
+ while (j--) this.eraseLine(j);
+ break;
+ case 3:
+ ; // no saved lines
+ break;
+ }
+};
+
+// CSI Ps K Erase in Line (EL).
+// Ps = 0 -> Erase to Right (default).
+// Ps = 1 -> Erase to Left.
+// Ps = 2 -> Erase All.
+// CSI ? Ps K
+// Erase in Line (DECSEL).
+// Ps = 0 -> Selective Erase to Right (default).
+// Ps = 1 -> Selective Erase to Left.
+// Ps = 2 -> Selective Erase All.
+Terminal.prototype.eraseInLine = function(params) {
+ switch (params[0]) {
+ case 0:
+ this.eraseRight(this.x, this.y);
+ break;
+ case 1:
+ this.eraseLeft(this.x, this.y);
+ break;
+ case 2:
+ this.eraseLine(this.y);
+ break;
+ }
+};
+
+// CSI Pm m Character Attributes (SGR).
+// Ps = 0 -> Normal (default).
+// Ps = 1 -> Bold.
+// Ps = 4 -> Underlined.
+// Ps = 5 -> Blink (appears as Bold).
+// Ps = 7 -> Inverse.
+// Ps = 8 -> Invisible, i.e., hidden (VT300).
+// Ps = 2 2 -> Normal (neither bold nor faint).
+// Ps = 2 4 -> Not underlined.
+// Ps = 2 5 -> Steady (not blinking).
+// Ps = 2 7 -> Positive (not inverse).
+// Ps = 2 8 -> Visible, i.e., not hidden (VT300).
+// Ps = 3 0 -> Set foreground color to Black.
+// Ps = 3 1 -> Set foreground color to Red.
+// Ps = 3 2 -> Set foreground color to Green.
+// Ps = 3 3 -> Set foreground color to Yellow.
+// Ps = 3 4 -> Set foreground color to Blue.
+// Ps = 3 5 -> Set foreground color to Magenta.
+// Ps = 3 6 -> Set foreground color to Cyan.
+// Ps = 3 7 -> Set foreground color to White.
+// Ps = 3 9 -> Set foreground color to default (original).
+// Ps = 4 0 -> Set background color to Black.
+// Ps = 4 1 -> Set background color to Red.
+// Ps = 4 2 -> Set background color to Green.
+// Ps = 4 3 -> Set background color to Yellow.
+// Ps = 4 4 -> Set background color to Blue.
+// Ps = 4 5 -> Set background color to Magenta.
+// Ps = 4 6 -> Set background color to Cyan.
+// Ps = 4 7 -> Set background color to White.
+// Ps = 4 9 -> Set background color to default (original).
+
+// If 16-color support is compiled, the following apply. Assume
+// that xterm's resources are set so that the ISO color codes are
+// the first 8 of a set of 16. Then the aixterm colors are the
+// bright versions of the ISO colors:
+// Ps = 9 0 -> Set foreground color to Black.
+// Ps = 9 1 -> Set foreground color to Red.
+// Ps = 9 2 -> Set foreground color to Green.
+// Ps = 9 3 -> Set foreground color to Yellow.
+// Ps = 9 4 -> Set foreground color to Blue.
+// Ps = 9 5 -> Set foreground color to Magenta.
+// Ps = 9 6 -> Set foreground color to Cyan.
+// Ps = 9 7 -> Set foreground color to White.
+// Ps = 1 0 0 -> Set background color to Black.
+// Ps = 1 0 1 -> Set background color to Red.
+// Ps = 1 0 2 -> Set background color to Green.
+// Ps = 1 0 3 -> Set background color to Yellow.
+// Ps = 1 0 4 -> Set background color to Blue.
+// Ps = 1 0 5 -> Set background color to Magenta.
+// Ps = 1 0 6 -> Set background color to Cyan.
+// Ps = 1 0 7 -> Set background color to White.
+
+// If xterm is compiled with the 16-color support disabled, it
+// supports the following, from rxvt:
+// Ps = 1 0 0 -> Set foreground and background color to
+// default.
+
+// If 88- or 256-color support is compiled, the following apply.
+// Ps = 3 8 ; 5 ; Ps -> Set foreground color to the second
+// Ps.
+// Ps = 4 8 ; 5 ; Ps -> Set background color to the second
+// Ps.
+Terminal.prototype.charAttributes = function(params) {
+ // Optimize a single SGR0.
+ if (params.length === 1 && params[0] === 0) {
+ this.curAttr = this.defAttr;
+ return;
+ }
+
+ var l = params.length
+ , i = 0
+ , flags = this.curAttr >> 18
+ , fg = (this.curAttr >> 9) & 0x1ff
+ , bg = this.curAttr & 0x1ff
+ , p;
+
+ for (; i < l; i++) {
+ p = params[i];
+ if (p >= 30 && p <= 37) {
+ // fg color 8
+ fg = p - 30;
+ } else if (p >= 40 && p <= 47) {
+ // bg color 8
+ bg = p - 40;
+ } else if (p >= 90 && p <= 97) {
+ // fg color 16
+ p += 8;
+ fg = p - 90;
+ } else if (p >= 100 && p <= 107) {
+ // bg color 16
+ p += 8;
+ bg = p - 100;
+ } else if (p === 0) {
+ // default
+ flags = this.defAttr >> 18;
+ fg = (this.defAttr >> 9) & 0x1ff;
+ bg = this.defAttr & 0x1ff;
+ // flags = 0;
+ // fg = 0x1ff;
+ // bg = 0x1ff;
+ } else if (p === 1) {
+ // bold text
+ flags |= 1;
+ } else if (p === 4) {
+ // underlined text
+ flags |= 2;
+ } else if (p === 5) {
+ // blink
+ flags |= 4;
+ } else if (p === 7) {
+ // inverse and positive
+ // test with: echo -e '\e[31m\e[42mhello\e[7mworld\e[27mhi\e[m'
+ flags |= 8;
+ } else if (p === 8) {
+ // invisible
+ flags |= 16;
+ } else if (p === 22) {
+ // not bold
+ flags &= ~1;
+ } else if (p === 24) {
+ // not underlined
+ flags &= ~2;
+ } else if (p === 25) {
+ // not blink
+ flags &= ~4;
+ } else if (p === 27) {
+ // not inverse
+ flags &= ~8;
+ } else if (p === 28) {
+ // not invisible
+ flags &= ~16;
+ } else if (p === 39) {
+ // reset fg
+ fg = (this.defAttr >> 9) & 0x1ff;
+ } else if (p === 49) {
+ // reset bg
+ bg = this.defAttr & 0x1ff;
+ } else if (p === 38) {
+ // fg color 256
+ if (params[i + 1] === 2) {
+ i += 2;
+ fg = matchColor(
+ params[i] & 0xff,
+ params[i + 1] & 0xff,
+ params[i + 2] & 0xff);
+ if (fg === -1) fg = 0x1ff;
+ i += 2;
+ } else if (params[i + 1] === 5) {
+ i += 2;
+ p = params[i] & 0xff;
+ fg = p;
+ }
+ } else if (p === 48) {
+ // bg color 256
+ if (params[i + 1] === 2) {
+ i += 2;
+ bg = matchColor(
+ params[i] & 0xff,
+ params[i + 1] & 0xff,
+ params[i + 2] & 0xff);
+ if (bg === -1) bg = 0x1ff;
+ i += 2;
+ } else if (params[i + 1] === 5) {
+ i += 2;
+ p = params[i] & 0xff;
+ bg = p;
+ }
+ } else if (p === 100) {
+ // reset fg/bg
+ fg = (this.defAttr >> 9) & 0x1ff;
+ bg = this.defAttr & 0x1ff;
+ } else {
+ this.error('Unknown SGR attribute: %d.', p);
+ }
+ }
+
+ this.curAttr = (flags << 18) | (fg << 9) | bg;
+};
+
+// CSI Ps n Device Status Report (DSR).
+// Ps = 5 -> Status Report. Result (``OK'') is
+// CSI 0 n
+// Ps = 6 -> Report Cursor Position (CPR) [row;column].
+// Result is
+// CSI r ; c R
+// CSI ? Ps n
+// Device Status Report (DSR, DEC-specific).
+// Ps = 6 -> Report Cursor Position (CPR) [row;column] as CSI
+// ? r ; c R (assumes page is zero).
+// Ps = 1 5 -> Report Printer status as CSI ? 1 0 n (ready).
+// or CSI ? 1 1 n (not ready).
+// Ps = 2 5 -> Report UDK status as CSI ? 2 0 n (unlocked)
+// or CSI ? 2 1 n (locked).
+// Ps = 2 6 -> Report Keyboard status as
+// CSI ? 2 7 ; 1 ; 0 ; 0 n (North American).
+// The last two parameters apply to VT400 & up, and denote key-
+// board ready and LK01 respectively.
+// Ps = 5 3 -> Report Locator status as
+// CSI ? 5 3 n Locator available, if compiled-in, or
+// CSI ? 5 0 n No Locator, if not.
+Terminal.prototype.deviceStatus = function(params) {
+ if (!this.prefix) {
+ switch (params[0]) {
+ case 5:
+ // status report
+ this.send('\x1b[0n');
+ break;
+ case 6:
+ // cursor position
+ this.send('\x1b['
+ + (this.y + 1)
+ + ';'
+ + (this.x + 1)
+ + 'R');
+ break;
+ }
+ } else if (this.prefix === '?') {
+ // modern xterm doesnt seem to
+ // respond to any of these except ?6, 6, and 5
+ switch (params[0]) {
+ case 6:
+ // cursor position
+ this.send('\x1b[?'
+ + (this.y + 1)
+ + ';'
+ + (this.x + 1)
+ + 'R');
+ break;
+ case 15:
+ // no printer
+ // this.send('\x1b[?11n');
+ break;
+ case 25:
+ // dont support user defined keys
+ // this.send('\x1b[?21n');
+ break;
+ case 26:
+ // north american keyboard
+ // this.send('\x1b[?27;1;0;0n');
+ break;
+ case 53:
+ // no dec locator/mouse
+ // this.send('\x1b[?50n');
+ break;
+ }
+ }
+};
+
+/**
+ * Additions
+ */
+
+// CSI Ps @
+// Insert Ps (Blank) Character(s) (default = 1) (ICH).
+Terminal.prototype.insertChars = function(params) {
+ var param, row, j, ch;
+
+ param = params[0];
+ if (param < 1) param = 1;
+
+ row = this.y + this.ybase;
+ j = this.x;
+ ch = [this.eraseAttr(), ' ']; // xterm
+
+ while (param-- && j < this.cols) {
+ this.lines[row].splice(j++, 0, ch);
+ this.lines[row].pop();
+ }
+};
+
+// CSI Ps E
+// Cursor Next Line Ps Times (default = 1) (CNL).
+// same as CSI Ps B ?
+Terminal.prototype.cursorNextLine = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y += param;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ }
+ this.x = 0;
+};
+
+// CSI Ps F
+// Cursor Preceding Line Ps Times (default = 1) (CNL).
+// reuse CSI Ps A ?
+Terminal.prototype.cursorPrecedingLine = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y -= param;
+ if (this.y < 0) this.y = 0;
+ this.x = 0;
+};
+
+// CSI Ps G
+// Cursor Character Absolute [column] (default = [row,1]) (CHA).
+Terminal.prototype.cursorCharAbsolute = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.x = param - 1;
+};
+
+// CSI Ps L
+// Insert Ps Line(s) (default = 1) (IL).
+Terminal.prototype.insertLines = function(params) {
+ var param, row, j;
+
+ param = params[0];
+ if (param < 1) param = 1;
+ row = this.y + this.ybase;
+
+ j = this.rows - 1 - this.scrollBottom;
+ j = this.rows - 1 + this.ybase - j + 1;
+
+ while (param--) {
+ // test: echo -e '\e[44m\e[1L\e[0m'
+ // blankLine(true) - xterm/linux behavior
+ this.lines.splice(row, 0, this.blankLine(true));
+ this.lines.splice(j, 1);
+ }
+
+ // this.maxRange();
+ this.updateRange(this.y);
+ this.updateRange(this.scrollBottom);
+};
+
+// CSI Ps M
+// Delete Ps Line(s) (default = 1) (DL).
+Terminal.prototype.deleteLines = function(params) {
+ var param, row, j;
+
+ param = params[0];
+ if (param < 1) param = 1;
+ row = this.y + this.ybase;
+
+ j = this.rows - 1 - this.scrollBottom;
+ j = this.rows - 1 + this.ybase - j;
+
+ while (param--) {
+ // test: echo -e '\e[44m\e[1M\e[0m'
+ // blankLine(true) - xterm/linux behavior
+ this.lines.splice(j + 1, 0, this.blankLine(true));
+ this.lines.splice(row, 1);
+ }
+
+ // this.maxRange();
+ this.updateRange(this.y);
+ this.updateRange(this.scrollBottom);
+};
+
+// CSI Ps P
+// Delete Ps Character(s) (default = 1) (DCH).
+Terminal.prototype.deleteChars = function(params) {
+ var param, row, ch;
+
+ param = params[0];
+ if (param < 1) param = 1;
+
+ row = this.y + this.ybase;
+ ch = [this.eraseAttr(), ' ']; // xterm
+
+ while (param--) {
+ this.lines[row].splice(this.x, 1);
+ this.lines[row].push(ch);
+ }
+};
+
+// CSI Ps X
+// Erase Ps Character(s) (default = 1) (ECH).
+Terminal.prototype.eraseChars = function(params) {
+ var param, row, j, ch;
+
+ param = params[0];
+ if (param < 1) param = 1;
+
+ row = this.y + this.ybase;
+ j = this.x;
+ ch = [this.eraseAttr(), ' ']; // xterm
+
+ while (param-- && j < this.cols) {
+ this.lines[row][j++] = ch;
+ }
+};
+
+// CSI Pm ` Character Position Absolute
+// [column] (default = [row,1]) (HPA).
+Terminal.prototype.charPosAbsolute = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.x = param - 1;
+ if (this.x >= this.cols) {
+ this.x = this.cols - 1;
+ }
+};
+
+// 141 61 a * HPR -
+// Horizontal Position Relative
+// reuse CSI Ps C ?
+Terminal.prototype.HPositionRelative = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.x += param;
+ if (this.x >= this.cols) {
+ this.x = this.cols - 1;
+ }
+};
+
+// CSI Ps c Send Device Attributes (Primary DA).
+// Ps = 0 or omitted -> request attributes from terminal. The
+// response depends on the decTerminalID resource setting.
+// -> CSI ? 1 ; 2 c (``VT100 with Advanced Video Option'')
+// -> CSI ? 1 ; 0 c (``VT101 with No Options'')
+// -> CSI ? 6 c (``VT102'')
+// -> CSI ? 6 0 ; 1 ; 2 ; 6 ; 8 ; 9 ; 1 5 ; c (``VT220'')
+// The VT100-style response parameters do not mean anything by
+// themselves. VT220 parameters do, telling the host what fea-
+// tures the terminal supports:
+// Ps = 1 -> 132-columns.
+// Ps = 2 -> Printer.
+// Ps = 6 -> Selective erase.
+// Ps = 8 -> User-defined keys.
+// Ps = 9 -> National replacement character sets.
+// Ps = 1 5 -> Technical characters.
+// Ps = 2 2 -> ANSI color, e.g., VT525.
+// Ps = 2 9 -> ANSI text locator (i.e., DEC Locator mode).
+// CSI > Ps c
+// Send Device Attributes (Secondary DA).
+// Ps = 0 or omitted -> request the terminal's identification
+// code. The response depends on the decTerminalID resource set-
+// ting. It should apply only to VT220 and up, but xterm extends
+// this to VT100.
+// -> CSI > Pp ; Pv ; Pc c
+// where Pp denotes the terminal type
+// Pp = 0 -> ``VT100''.
+// Pp = 1 -> ``VT220''.
+// and Pv is the firmware version (for xterm, this was originally
+// the XFree86 patch number, starting with 95). In a DEC termi-
+// nal, Pc indicates the ROM cartridge registration number and is
+// always zero.
+// More information:
+// xterm/charproc.c - line 2012, for more information.
+// vim responds with ^[[?0c or ^[[?1c after the terminal's response (?)
+Terminal.prototype.sendDeviceAttributes = function(params) {
+ if (params[0] > 0) return;
+
+ if (!this.prefix) {
+ if (this.is('xterm')
+ || this.is('rxvt-unicode')
+ || this.is('screen')) {
+ this.send('\x1b[?1;2c');
+ } else if (this.is('linux')) {
+ this.send('\x1b[?6c');
+ }
+ } else if (this.prefix === '>') {
+ // xterm and urxvt
+ // seem to spit this
+ // out around ~370 times (?).
+ if (this.is('xterm')) {
+ this.send('\x1b[>0;276;0c');
+ } else if (this.is('rxvt-unicode')) {
+ this.send('\x1b[>85;95;0c');
+ } else if (this.is('linux')) {
+ // not supported by linux console.
+ // linux console echoes parameters.
+ this.send(params[0] + 'c');
+ } else if (this.is('screen')) {
+ this.send('\x1b[>83;40003;0c');
+ }
+ }
+};
+
+// CSI Pm d
+// Line Position Absolute [row] (default = [1,column]) (VPA).
+Terminal.prototype.linePosAbsolute = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y = param - 1;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ }
+};
+
+// 145 65 e * VPR - Vertical Position Relative
+// reuse CSI Ps B ?
+Terminal.prototype.VPositionRelative = function(params) {
+ var param = params[0];
+ if (param < 1) param = 1;
+ this.y += param;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ }
+};
+
+// CSI Ps ; Ps f
+// Horizontal and Vertical Position [row;column] (default =
+// [1,1]) (HVP).
+Terminal.prototype.HVPosition = function(params) {
+ if (params[0] < 1) params[0] = 1;
+ if (params[1] < 1) params[1] = 1;
+
+ this.y = params[0] - 1;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ }
+
+ this.x = params[1] - 1;
+ if (this.x >= this.cols) {
+ this.x = this.cols - 1;
+ }
+};
+
+// CSI Pm h Set Mode (SM).
+// Ps = 2 -> Keyboard Action Mode (AM).
+// Ps = 4 -> Insert Mode (IRM).
+// Ps = 1 2 -> Send/receive (SRM).
+// Ps = 2 0 -> Automatic Newline (LNM).
+// CSI ? Pm h
+// DEC Private Mode Set (DECSET).
+// Ps = 1 -> Application Cursor Keys (DECCKM).
+// Ps = 2 -> Designate USASCII for character sets G0-G3
+// (DECANM), and set VT100 mode.
+// Ps = 3 -> 132 Column Mode (DECCOLM).
+// Ps = 4 -> Smooth (Slow) Scroll (DECSCLM).
+// Ps = 5 -> Reverse Video (DECSCNM).
+// Ps = 6 -> Origin Mode (DECOM).
+// Ps = 7 -> Wraparound Mode (DECAWM).
+// Ps = 8 -> Auto-repeat Keys (DECARM).
+// Ps = 9 -> Send Mouse X & Y on button press. See the sec-
+// tion Mouse Tracking.
+// Ps = 1 0 -> Show toolbar (rxvt).
+// Ps = 1 2 -> Start Blinking Cursor (att610).
+// Ps = 1 8 -> Print form feed (DECPFF).
+// Ps = 1 9 -> Set print extent to full screen (DECPEX).
+// Ps = 2 5 -> Show Cursor (DECTCEM).
+// Ps = 3 0 -> Show scrollbar (rxvt).
+// Ps = 3 5 -> Enable font-shifting functions (rxvt).
+// Ps = 3 8 -> Enter Tektronix Mode (DECTEK).
+// Ps = 4 0 -> Allow 80 -> 132 Mode.
+// Ps = 4 1 -> more(1) fix (see curses resource).
+// Ps = 4 2 -> Enable Nation Replacement Character sets (DECN-
+// RCM).
+// Ps = 4 4 -> Turn On Margin Bell.
+// Ps = 4 5 -> Reverse-wraparound Mode.
+// Ps = 4 6 -> Start Logging. This is normally disabled by a
+// compile-time option.
+// Ps = 4 7 -> Use Alternate Screen Buffer. (This may be dis-
+// abled by the titeInhibit resource).
+// Ps = 6 6 -> Application keypad (DECNKM).
+// Ps = 6 7 -> Backarrow key sends backspace (DECBKM).
+// Ps = 1 0 0 0 -> Send Mouse X & Y on button press and
+// release. See the section Mouse Tracking.
+// Ps = 1 0 0 1 -> Use Hilite Mouse Tracking.
+// Ps = 1 0 0 2 -> Use Cell Motion Mouse Tracking.
+// Ps = 1 0 0 3 -> Use All Motion Mouse Tracking.
+// Ps = 1 0 0 4 -> Send FocusIn/FocusOut events.
+// Ps = 1 0 0 5 -> Enable Extended Mouse Mode.
+// Ps = 1 0 1 0 -> Scroll to bottom on tty output (rxvt).
+// Ps = 1 0 1 1 -> Scroll to bottom on key press (rxvt).
+// Ps = 1 0 3 4 -> Interpret "meta" key, sets eighth bit.
+// (enables the eightBitInput resource).
+// Ps = 1 0 3 5 -> Enable special modifiers for Alt and Num-
+// Lock keys. (This enables the numLock resource).
+// Ps = 1 0 3 6 -> Send ESC when Meta modifies a key. (This
+// enables the metaSendsEscape resource).
+// Ps = 1 0 3 7 -> Send DEL from the editing-keypad Delete
+// key.
+// Ps = 1 0 3 9 -> Send ESC when Alt modifies a key. (This
+// enables the altSendsEscape resource).
+// Ps = 1 0 4 0 -> Keep selection even if not highlighted.
+// (This enables the keepSelection resource).
+// Ps = 1 0 4 1 -> Use the CLIPBOARD selection. (This enables
+// the selectToClipboard resource).
+// Ps = 1 0 4 2 -> Enable Urgency window manager hint when
+// Control-G is received. (This enables the bellIsUrgent
+// resource).
+// Ps = 1 0 4 3 -> Enable raising of the window when Control-G
+// is received. (enables the popOnBell resource).
+// Ps = 1 0 4 7 -> Use Alternate Screen Buffer. (This may be
+// disabled by the titeInhibit resource).
+// Ps = 1 0 4 8 -> Save cursor as in DECSC. (This may be dis-
+// abled by the titeInhibit resource).
+// Ps = 1 0 4 9 -> Save cursor as in DECSC and use Alternate
+// Screen Buffer, clearing it first. (This may be disabled by
+// the titeInhibit resource). This combines the effects of the 1
+// 0 4 7 and 1 0 4 8 modes. Use this with terminfo-based
+// applications rather than the 4 7 mode.
+// Ps = 1 0 5 0 -> Set terminfo/termcap function-key mode.
+// Ps = 1 0 5 1 -> Set Sun function-key mode.
+// Ps = 1 0 5 2 -> Set HP function-key mode.
+// Ps = 1 0 5 3 -> Set SCO function-key mode.
+// Ps = 1 0 6 0 -> Set legacy keyboard emulation (X11R6).
+// Ps = 1 0 6 1 -> Set VT220 keyboard emulation.
+// Ps = 2 0 0 4 -> Set bracketed paste mode.
+// Modes:
+// http://vt100.net/docs/vt220-rm/chapter4.html
+Terminal.prototype.setMode = function(params) {
+ if (typeof params === 'object') {
+ var l = params.length
+ , i = 0;
+
+ for (; i < l; i++) {
+ this.setMode(params[i]);
+ }
+
+ return;
+ }
+
+ if (!this.prefix) {
+ switch (params) {
+ case 4:
+ this.insertMode = true;
+ break;
+ case 20:
+ //this.convertEol = true;
+ break;
+ }
+ } else if (this.prefix === '?') {
+ switch (params) {
+ case 1:
+ this.applicationCursor = true;
+ break;
+ case 2:
+ this.setgCharset(0, Terminal.charsets.US);
+ this.setgCharset(1, Terminal.charsets.US);
+ this.setgCharset(2, Terminal.charsets.US);
+ this.setgCharset(3, Terminal.charsets.US);
+ // set VT100 mode here
+ break;
+ case 3: // 132 col mode
+ this.savedCols = this.cols;
+ this.resize(132, this.rows);
+ break;
+ case 6:
+ this.originMode = true;
+ break;
+ case 7:
+ this.wraparoundMode = true;
+ break;
+ case 12:
+ // this.cursorBlink = true;
+ break;
+ case 66:
+ this.log('Serial port requested application keypad.');
+ this.applicationKeypad = true;
+ break;
+ case 9: // X10 Mouse
+ // no release, no motion, no wheel, no modifiers.
+ case 1000: // vt200 mouse
+ // no motion.
+ // no modifiers, except control on the wheel.
+ case 1002: // button event mouse
+ case 1003: // any event mouse
+ // any event - sends motion events,
+ // even if there is no button held down.
+ this.x10Mouse = params === 9;
+ this.vt200Mouse = params === 1000;
+ this.normalMouse = params > 1000;
+ this.mouseEvents = true;
+ this.element.style.cursor = 'default';
+ this.log('Binding to mouse events.');
+ break;
+ case 1004: // send focusin/focusout events
+ // focusin: ^[[I
+ // focusout: ^[[O
+ this.sendFocus = true;
+ break;
+ case 1005: // utf8 ext mode mouse
+ this.utfMouse = true;
+ // for wide terminals
+ // simply encodes large values as utf8 characters
+ break;
+ case 1006: // sgr ext mode mouse
+ this.sgrMouse = true;
+ // for wide terminals
+ // does not add 32 to fields
+ // press: ^[[<b;x;yM
+ // release: ^[[<b;x;ym
+ break;
+ case 1015: // urxvt ext mode mouse
+ this.urxvtMouse = true;
+ // for wide terminals
+ // numbers for fields
+ // press: ^[[b;x;yM
+ // motion: ^[[b;x;yT
+ break;
+ case 25: // show cursor
+ this.cursorHidden = false;
+ break;
+ case 1049: // alt screen buffer cursor
+ //this.saveCursor();
+ ; // FALL-THROUGH
+ case 47: // alt screen buffer
+ case 1047: // alt screen buffer
+ if (!this.normal) {
+ var normal = {
+ lines: this.lines,
+ ybase: this.ybase,
+ ydisp: this.ydisp,
+ x: this.x,
+ y: this.y,
+ scrollTop: this.scrollTop,
+ scrollBottom: this.scrollBottom,
+ tabs: this.tabs
+ // XXX save charset(s) here?
+ // charset: this.charset,
+ // glevel: this.glevel,
+ // charsets: this.charsets
+ };
+ this.reset();
+ this.normal = normal;
+ this.showCursor();
+ }
+ break;
+ }
+ }
+};
+
+// CSI Pm l Reset Mode (RM).
+// Ps = 2 -> Keyboard Action Mode (AM).
+// Ps = 4 -> Replace Mode (IRM).
+// Ps = 1 2 -> Send/receive (SRM).
+// Ps = 2 0 -> Normal Linefeed (LNM).
+// CSI ? Pm l
+// DEC Private Mode Reset (DECRST).
+// Ps = 1 -> Normal Cursor Keys (DECCKM).
+// Ps = 2 -> Designate VT52 mode (DECANM).
+// Ps = 3 -> 80 Column Mode (DECCOLM).
+// Ps = 4 -> Jump (Fast) Scroll (DECSCLM).
+// Ps = 5 -> Normal Video (DECSCNM).
+// Ps = 6 -> Normal Cursor Mode (DECOM).
+// Ps = 7 -> No Wraparound Mode (DECAWM).
+// Ps = 8 -> No Auto-repeat Keys (DECARM).
+// Ps = 9 -> Don't send Mouse X & Y on button press.
+// Ps = 1 0 -> Hide toolbar (rxvt).
+// Ps = 1 2 -> Stop Blinking Cursor (att610).
+// Ps = 1 8 -> Don't print form feed (DECPFF).
+// Ps = 1 9 -> Limit print to scrolling region (DECPEX).
+// Ps = 2 5 -> Hide Cursor (DECTCEM).
+// Ps = 3 0 -> Don't show scrollbar (rxvt).
+// Ps = 3 5 -> Disable font-shifting functions (rxvt).
+// Ps = 4 0 -> Disallow 80 -> 132 Mode.
+// Ps = 4 1 -> No more(1) fix (see curses resource).
+// Ps = 4 2 -> Disable Nation Replacement Character sets (DEC-
+// NRCM).
+// Ps = 4 4 -> Turn Off Margin Bell.
+// Ps = 4 5 -> No Reverse-wraparound Mode.
+// Ps = 4 6 -> Stop Logging. (This is normally disabled by a
+// compile-time option).
+// Ps = 4 7 -> Use Normal Screen Buffer.
+// Ps = 6 6 -> Numeric keypad (DECNKM).
+// Ps = 6 7 -> Backarrow key sends delete (DECBKM).
+// Ps = 1 0 0 0 -> Don't send Mouse X & Y on button press and
+// release. See the section Mouse Tracking.
+// Ps = 1 0 0 1 -> Don't use Hilite Mouse Tracking.
+// Ps = 1 0 0 2 -> Don't use Cell Motion Mouse Tracking.
+// Ps = 1 0 0 3 -> Don't use All Motion Mouse Tracking.
+// Ps = 1 0 0 4 -> Don't send FocusIn/FocusOut events.
+// Ps = 1 0 0 5 -> Disable Extended Mouse Mode.
+// Ps = 1 0 1 0 -> Don't scroll to bottom on tty output
+// (rxvt).
+// Ps = 1 0 1 1 -> Don't scroll to bottom on key press (rxvt).
+// Ps = 1 0 3 4 -> Don't interpret "meta" key. (This disables
+// the eightBitInput resource).
+// Ps = 1 0 3 5 -> Disable special modifiers for Alt and Num-
+// Lock keys. (This disables the numLock resource).
+// Ps = 1 0 3 6 -> Don't send ESC when Meta modifies a key.
+// (This disables the metaSendsEscape resource).
+// Ps = 1 0 3 7 -> Send VT220 Remove from the editing-keypad
+// Delete key.
+// Ps = 1 0 3 9 -> Don't send ESC when Alt modifies a key.
+// (This disables the altSendsEscape resource).
+// Ps = 1 0 4 0 -> Do not keep selection when not highlighted.
+// (This disables the keepSelection resource).
+// Ps = 1 0 4 1 -> Use the PRIMARY selection. (This disables
+// the selectToClipboard resource).
+// Ps = 1 0 4 2 -> Disable Urgency window manager hint when
+// Control-G is received. (This disables the bellIsUrgent
+// resource).
+// Ps = 1 0 4 3 -> Disable raising of the window when Control-
+// G is received. (This disables the popOnBell resource).
+// Ps = 1 0 4 7 -> Use Normal Screen Buffer, clearing screen
+// first if in the Alternate Screen. (This may be disabled by
+// the titeInhibit resource).
+// Ps = 1 0 4 8 -> Restore cursor as in DECRC. (This may be
+// disabled by the titeInhibit resource).
+// Ps = 1 0 4 9 -> Use Normal Screen Buffer and restore cursor
+// as in DECRC. (This may be disabled by the titeInhibit
+// resource). This combines the effects of the 1 0 4 7 and 1 0
+// 4 8 modes. Use this with terminfo-based applications rather
+// than the 4 7 mode.
+// Ps = 1 0 5 0 -> Reset terminfo/termcap function-key mode.
+// Ps = 1 0 5 1 -> Reset Sun function-key mode.
+// Ps = 1 0 5 2 -> Reset HP function-key mode.
+// Ps = 1 0 5 3 -> Reset SCO function-key mode.
+// Ps = 1 0 6 0 -> Reset legacy keyboard emulation (X11R6).
+// Ps = 1 0 6 1 -> Reset keyboard emulation to Sun/PC style.
+// Ps = 2 0 0 4 -> Reset bracketed paste mode.
+Terminal.prototype.resetMode = function(params) {
+ if (typeof params === 'object') {
+ var l = params.length
+ , i = 0;
+
+ for (; i < l; i++) {
+ this.resetMode(params[i]);
+ }
+
+ return;
+ }
+
+ if (!this.prefix) {
+ switch (params) {
+ case 4:
+ this.insertMode = false;
+ break;
+ case 20:
+ //this.convertEol = false;
+ break;
+ }
+ } else if (this.prefix === '?') {
+ switch (params) {
+ case 1:
+ this.applicationCursor = false;
+ break;
+ case 3:
+ if (this.cols === 132 && this.savedCols) {
+ this.resize(this.savedCols, this.rows);
+ }
+ delete this.savedCols;
+ break;
+ case 6:
+ this.originMode = false;
+ break;
+ case 7:
+ this.wraparoundMode = false;
+ break;
+ case 12:
+ // this.cursorBlink = false;
+ break;
+ case 66:
+ this.log('Switching back to normal keypad.');
+ this.applicationKeypad = false;
+ break;
+ case 9: // X10 Mouse
+ case 1000: // vt200 mouse
+ case 1002: // button event mouse
+ case 1003: // any event mouse
+ this.x10Mouse = false;
+ this.vt200Mouse = false;
+ this.normalMouse = false;
+ this.mouseEvents = false;
+ this.element.style.cursor = '';
+ break;
+ case 1004: // send focusin/focusout events
+ this.sendFocus = false;
+ break;
+ case 1005: // utf8 ext mode mouse
+ this.utfMouse = false;
+ break;
+ case 1006: // sgr ext mode mouse
+ this.sgrMouse = false;
+ break;
+ case 1015: // urxvt ext mode mouse
+ this.urxvtMouse = false;
+ break;
+ case 25: // hide cursor
+ this.cursorHidden = true;
+ break;
+ case 1049: // alt screen buffer cursor
+ ; // FALL-THROUGH
+ case 47: // normal screen buffer
+ case 1047: // normal screen buffer - clearing it first
+ if (this.normal) {
+ this.lines = this.normal.lines;
+ this.ybase = this.normal.ybase;
+ this.ydisp = this.normal.ydisp;
+ this.x = this.normal.x;
+ this.y = this.normal.y;
+ this.scrollTop = this.normal.scrollTop;
+ this.scrollBottom = this.normal.scrollBottom;
+ this.tabs = this.normal.tabs;
+ this.normal = null;
+ // if (params === 1049) {
+ // this.x = this.savedX;
+ // this.y = this.savedY;
+ // }
+ this.refresh(0, this.rows - 1);
+ this.showCursor();
+ }
+ break;
+ }
+ }
+};
+
+// CSI Ps ; Ps r
+// Set Scrolling Region [top;bottom] (default = full size of win-
+// dow) (DECSTBM).
+// CSI ? Pm r
+Terminal.prototype.setScrollRegion = function(params) {
+ if (this.prefix) return;
+ this.scrollTop = (params[0] || 1) - 1;
+ this.scrollBottom = (params[1] || this.rows) - 1;
+ this.x = 0;
+ this.y = 0;
+};
+
+// CSI s
+// Save cursor (ANSI.SYS).
+Terminal.prototype.saveCursor = function(params) {
+ this.savedX = this.x;
+ this.savedY = this.y;
+};
+
+// CSI u
+// Restore cursor (ANSI.SYS).
+Terminal.prototype.restoreCursor = function(params) {
+ this.x = this.savedX || 0;
+ this.y = this.savedY || 0;
+};
+
+/**
+ * Lesser Used
+ */
+
+// CSI Ps I
+// Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
+Terminal.prototype.cursorForwardTab = function(params) {
+ var param = params[0] || 1;
+ while (param--) {
+ this.x = this.nextStop();
+ }
+};
+
+// CSI Ps S Scroll up Ps lines (default = 1) (SU).
+Terminal.prototype.scrollUp = function(params) {
+ var param = params[0] || 1;
+ while (param--) {
+ this.lines.splice(this.ybase + this.scrollTop, 1);
+ this.lines.splice(this.ybase + this.scrollBottom, 0, this.blankLine());
+ }
+ // this.maxRange();
+ this.updateRange(this.scrollTop);
+ this.updateRange(this.scrollBottom);
+};
+
+// CSI Ps T Scroll down Ps lines (default = 1) (SD).
+Terminal.prototype.scrollDown = function(params) {
+ var param = params[0] || 1;
+ while (param--) {
+ this.lines.splice(this.ybase + this.scrollBottom, 1);
+ this.lines.splice(this.ybase + this.scrollTop, 0, this.blankLine());
+ }
+ // this.maxRange();
+ this.updateRange(this.scrollTop);
+ this.updateRange(this.scrollBottom);
+};
+
+// CSI Ps ; Ps ; Ps ; Ps ; Ps T
+// Initiate highlight mouse tracking. Parameters are
+// [func;startx;starty;firstrow;lastrow]. See the section Mouse
+// Tracking.
+Terminal.prototype.initMouseTracking = function(params) {
+ // Relevant: DECSET 1001
+};
+
+// CSI > Ps; Ps T
+// Reset one or more features of the title modes to the default
+// value. Normally, "reset" disables the feature. It is possi-
+// ble to disable the ability to reset features by compiling a
+// different default for the title modes into xterm.
+// Ps = 0 -> Do not set window/icon labels using hexadecimal.
+// Ps = 1 -> Do not query window/icon labels using hexadeci-
+// mal.
+// Ps = 2 -> Do not set window/icon labels using UTF-8.
+// Ps = 3 -> Do not query window/icon labels using UTF-8.
+// (See discussion of "Title Modes").
+Terminal.prototype.resetTitleModes = function(params) {
+ ;
+};
+
+// CSI Ps Z Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
+Terminal.prototype.cursorBackwardTab = function(params) {
+ var param = params[0] || 1;
+ while (param--) {
+ this.x = this.prevStop();
+ }
+};
+
+// CSI Ps b Repeat the preceding graphic character Ps times (REP).
+Terminal.prototype.repeatPrecedingCharacter = function(params) {
+ var param = params[0] || 1
+ , line = this.lines[this.ybase + this.y]
+ , ch = line[this.x - 1] || [this.defAttr, ' '];
+
+ while (param--) line[this.x++] = ch;
+};
+
+// CSI Ps g Tab Clear (TBC).
+// Ps = 0 -> Clear Current Column (default).
+// Ps = 3 -> Clear All.
+// Potentially:
+// Ps = 2 -> Clear Stops on Line.
+// http://vt100.net/annarbor/aaa-ug/section6.html
+Terminal.prototype.tabClear = function(params) {
+ var param = params[0];
+ if (param <= 0) {
+ delete this.tabs[this.x];
+ } else if (param === 3) {
+ this.tabs = {};
+ }
+};
+
+// CSI Pm i Media Copy (MC).
+// Ps = 0 -> Print screen (default).
+// Ps = 4 -> Turn off printer controller mode.
+// Ps = 5 -> Turn on printer controller mode.
+// CSI ? Pm i
+// Media Copy (MC, DEC-specific).
+// Ps = 1 -> Print line containing cursor.
+// Ps = 4 -> Turn off autoprint mode.
+// Ps = 5 -> Turn on autoprint mode.
+// Ps = 1 0 -> Print composed display, ignores DECPEX.
+// Ps = 1 1 -> Print all pages.
+Terminal.prototype.mediaCopy = function(params) {
+ ;
+};
+
+// CSI > Ps; Ps m
+// Set or reset resource-values used by xterm to decide whether
+// to construct escape sequences holding information about the
+// modifiers pressed with a given key. The first parameter iden-
+// tifies the resource to set/reset. The second parameter is the
+// value to assign to the resource. If the second parameter is
+// omitted, the resource is reset to its initial value.
+// Ps = 1 -> modifyCursorKeys.
+// Ps = 2 -> modifyFunctionKeys.
+// Ps = 4 -> modifyOtherKeys.
+// If no parameters are given, all resources are reset to their
+// initial values.
+Terminal.prototype.setResources = function(params) {
+ ;
+};
+
+// CSI > Ps n
+// Disable modifiers which may be enabled via the CSI > Ps; Ps m
+// sequence. This corresponds to a resource value of "-1", which
+// cannot be set with the other sequence. The parameter identi-
+// fies the resource to be disabled:
+// Ps = 1 -> modifyCursorKeys.
+// Ps = 2 -> modifyFunctionKeys.
+// Ps = 4 -> modifyOtherKeys.
+// If the parameter is omitted, modifyFunctionKeys is disabled.
+// When modifyFunctionKeys is disabled, xterm uses the modifier
+// keys to make an extended sequence of functions rather than
+// adding a parameter to each function key to denote the modi-
+// fiers.
+Terminal.prototype.disableModifiers = function(params) {
+ ;
+};
+
+// CSI > Ps p
+// Set resource value pointerMode. This is used by xterm to
+// decide whether to hide the pointer cursor as the user types.
+// Valid values for the parameter:
+// Ps = 0 -> never hide the pointer.
+// Ps = 1 -> hide if the mouse tracking mode is not enabled.
+// Ps = 2 -> always hide the pointer. If no parameter is
+// given, xterm uses the default, which is 1 .
+Terminal.prototype.setPointerMode = function(params) {
+ ;
+};
+
+// CSI ! p Soft terminal reset (DECSTR).
+// http://vt100.net/docs/vt220-rm/table4-10.html
+Terminal.prototype.softReset = function(params) {
+ this.cursorHidden = false;
+ this.insertMode = false;
+ this.originMode = false;
+ this.wraparoundMode = false; // autowrap
+ this.applicationKeypad = false; // ?
+ this.applicationCursor = false;
+ this.scrollTop = 0;
+ this.scrollBottom = this.rows - 1;
+ this.curAttr = this.defAttr;
+ this.x = this.y = 0; // ?
+ this.charset = null;
+ this.glevel = 0; // ??
+ this.charsets = [null]; // ??
+};
+
+// CSI Ps$ p
+// Request ANSI mode (DECRQM). For VT300 and up, reply is
+// CSI Ps; Pm$ y
+// where Ps is the mode number as in RM, and Pm is the mode
+// value:
+// 0 - not recognized
+// 1 - set
+// 2 - reset
+// 3 - permanently set
+// 4 - permanently reset
+Terminal.prototype.requestAnsiMode = function(params) {
+ ;
+};
+
+// CSI ? Ps$ p
+// Request DEC private mode (DECRQM). For VT300 and up, reply is
+// CSI ? Ps; Pm$ p
+// where Ps is the mode number as in DECSET, Pm is the mode value
+// as in the ANSI DECRQM.
+Terminal.prototype.requestPrivateMode = function(params) {
+ ;
+};
+
+// CSI Ps ; Ps " p
+// Set conformance level (DECSCL). Valid values for the first
+// parameter:
+// Ps = 6 1 -> VT100.
+// Ps = 6 2 -> VT200.
+// Ps = 6 3 -> VT300.
+// Valid values for the second parameter:
+// Ps = 0 -> 8-bit controls.
+// Ps = 1 -> 7-bit controls (always set for VT100).
+// Ps = 2 -> 8-bit controls.
+Terminal.prototype.setConformanceLevel = function(params) {
+ ;
+};
+
+// CSI Ps q Load LEDs (DECLL).
+// Ps = 0 -> Clear all LEDS (default).
+// Ps = 1 -> Light Num Lock.
+// Ps = 2 -> Light Caps Lock.
+// Ps = 3 -> Light Scroll Lock.
+// Ps = 2 1 -> Extinguish Num Lock.
+// Ps = 2 2 -> Extinguish Caps Lock.
+// Ps = 2 3 -> Extinguish Scroll Lock.
+Terminal.prototype.loadLEDs = function(params) {
+ ;
+};
+
+// CSI Ps SP q
+// Set cursor style (DECSCUSR, VT520).
+// Ps = 0 -> blinking block.
+// Ps = 1 -> blinking block (default).
+// Ps = 2 -> steady block.
+// Ps = 3 -> blinking underline.
+// Ps = 4 -> steady underline.
+Terminal.prototype.setCursorStyle = function(params) {
+ ;
+};
+
+// CSI Ps " q
+// Select character protection attribute (DECSCA). Valid values
+// for the parameter:
+// Ps = 0 -> DECSED and DECSEL can erase (default).
+// Ps = 1 -> DECSED and DECSEL cannot erase.
+// Ps = 2 -> DECSED and DECSEL can erase.
+Terminal.prototype.setCharProtectionAttr = function(params) {
+ ;
+};
+
+// CSI ? Pm r
+// Restore DEC Private Mode Values. The value of Ps previously
+// saved is restored. Ps values are the same as for DECSET.
+Terminal.prototype.restorePrivateValues = function(params) {
+ ;
+};
+
+// CSI Pt; Pl; Pb; Pr; Ps$ r
+// Change Attributes in Rectangular Area (DECCARA), VT400 and up.
+// Pt; Pl; Pb; Pr denotes the rectangle.
+// Ps denotes the SGR attributes to change: 0, 1, 4, 5, 7.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.setAttrInRectangle = function(params) {
+ var t = params[0]
+ , l = params[1]
+ , b = params[2]
+ , r = params[3]
+ , attr = params[4];
+
+ var line
+ , i;
+
+ for (; t < b + 1; t++) {
+ line = this.lines[this.ybase + t];
+ for (i = l; i < r; i++) {
+ line[i] = [attr, line[i][1]];
+ }
+ }
+
+ // this.maxRange();
+ this.updateRange(params[0]);
+ this.updateRange(params[2]);
+};
+
+// CSI ? Pm s
+// Save DEC Private Mode Values. Ps values are the same as for
+// DECSET.
+Terminal.prototype.savePrivateValues = function(params) {
+ ;
+};
+
+// CSI Ps ; Ps ; Ps t
+// Window manipulation (from dtterm, as well as extensions).
+// These controls may be disabled using the allowWindowOps
+// resource. Valid values for the first (and any additional
+// parameters) are:
+// Ps = 1 -> De-iconify window.
+// Ps = 2 -> Iconify window.
+// Ps = 3 ; x ; y -> Move window to [x, y].
+// Ps = 4 ; height ; width -> Resize the xterm window to
+// height and width in pixels.
+// Ps = 5 -> Raise the xterm window to the front of the stack-
+// ing order.
+// Ps = 6 -> Lower the xterm window to the bottom of the
+// stacking order.
+// Ps = 7 -> Refresh the xterm window.
+// Ps = 8 ; height ; width -> Resize the text area to
+// [height;width] in characters.
+// Ps = 9 ; 0 -> Restore maximized window.
+// Ps = 9 ; 1 -> Maximize window (i.e., resize to screen
+// size).
+// Ps = 1 0 ; 0 -> Undo full-screen mode.
+// Ps = 1 0 ; 1 -> Change to full-screen.
+// Ps = 1 1 -> Report xterm window state. If the xterm window
+// is open (non-iconified), it returns CSI 1 t . If the xterm
+// window is iconified, it returns CSI 2 t .
+// Ps = 1 3 -> Report xterm window position. Result is CSI 3
+// ; x ; y t
+// Ps = 1 4 -> Report xterm window in pixels. Result is CSI
+// 4 ; height ; width t
+// Ps = 1 8 -> Report the size of the text area in characters.
+// Result is CSI 8 ; height ; width t
+// Ps = 1 9 -> Report the size of the screen in characters.
+// Result is CSI 9 ; height ; width t
+// Ps = 2 0 -> Report xterm window's icon label. Result is
+// OSC L label ST
+// Ps = 2 1 -> Report xterm window's title. Result is OSC l
+// label ST
+// Ps = 2 2 ; 0 -> Save xterm icon and window title on
+// stack.
+// Ps = 2 2 ; 1 -> Save xterm icon title on stack.
+// Ps = 2 2 ; 2 -> Save xterm window title on stack.
+// Ps = 2 3 ; 0 -> Restore xterm icon and window title from
+// stack.
+// Ps = 2 3 ; 1 -> Restore xterm icon title from stack.
+// Ps = 2 3 ; 2 -> Restore xterm window title from stack.
+// Ps >= 2 4 -> Resize to Ps lines (DECSLPP).
+Terminal.prototype.manipulateWindow = function(params) {
+ ;
+};
+
+// CSI Pt; Pl; Pb; Pr; Ps$ t
+// Reverse Attributes in Rectangular Area (DECRARA), VT400 and
+// up.
+// Pt; Pl; Pb; Pr denotes the rectangle.
+// Ps denotes the attributes to reverse, i.e., 1, 4, 5, 7.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.reverseAttrInRectangle = function(params) {
+ ;
+};
+
+// CSI > Ps; Ps t
+// Set one or more features of the title modes. Each parameter
+// enables a single feature.
+// Ps = 0 -> Set window/icon labels using hexadecimal.
+// Ps = 1 -> Query window/icon labels using hexadecimal.
+// Ps = 2 -> Set window/icon labels using UTF-8.
+// Ps = 3 -> Query window/icon labels using UTF-8. (See dis-
+// cussion of "Title Modes")
+Terminal.prototype.setTitleModeFeature = function(params) {
+ ;
+};
+
+// CSI Ps SP t
+// Set warning-bell volume (DECSWBV, VT520).
+// Ps = 0 or 1 -> off.
+// Ps = 2 , 3 or 4 -> low.
+// Ps = 5 , 6 , 7 , or 8 -> high.
+Terminal.prototype.setWarningBellVolume = function(params) {
+ ;
+};
+
+// CSI Ps SP u
+// Set margin-bell volume (DECSMBV, VT520).
+// Ps = 1 -> off.
+// Ps = 2 , 3 or 4 -> low.
+// Ps = 0 , 5 , 6 , 7 , or 8 -> high.
+Terminal.prototype.setMarginBellVolume = function(params) {
+ ;
+};
+
+// CSI Pt; Pl; Pb; Pr; Pp; Pt; Pl; Pp$ v
+// Copy Rectangular Area (DECCRA, VT400 and up).
+// Pt; Pl; Pb; Pr denotes the rectangle.
+// Pp denotes the source page.
+// Pt; Pl denotes the target location.
+// Pp denotes the target page.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.copyRectangle = function(params) {
+ ;
+};
+
+// CSI Pt ; Pl ; Pb ; Pr ' w
+// Enable Filter Rectangle (DECEFR), VT420 and up.
+// Parameters are [top;left;bottom;right].
+// Defines the coordinates of a filter rectangle and activates
+// it. Anytime the locator is detected outside of the filter
+// rectangle, an outside rectangle event is generated and the
+// rectangle is disabled. Filter rectangles are always treated
+// as "one-shot" events. Any parameters that are omitted default
+// to the current locator position. If all parameters are omit-
+// ted, any locator motion will be reported. DECELR always can-
+// cels any prevous rectangle definition.
+Terminal.prototype.enableFilterRectangle = function(params) {
+ ;
+};
+
+// CSI Ps x Request Terminal Parameters (DECREQTPARM).
+// if Ps is a "0" (default) or "1", and xterm is emulating VT100,
+// the control sequence elicits a response of the same form whose
+// parameters describe the terminal:
+// Ps -> the given Ps incremented by 2.
+// Pn = 1 <- no parity.
+// Pn = 1 <- eight bits.
+// Pn = 1 <- 2 8 transmit 38.4k baud.
+// Pn = 1 <- 2 8 receive 38.4k baud.
+// Pn = 1 <- clock multiplier.
+// Pn = 0 <- STP flags.
+Terminal.prototype.requestParameters = function(params) {
+ ;
+};
+
+// CSI Ps x Select Attribute Change Extent (DECSACE).
+// Ps = 0 -> from start to end position, wrapped.
+// Ps = 1 -> from start to end position, wrapped.
+// Ps = 2 -> rectangle (exact).
+Terminal.prototype.selectChangeExtent = function(params) {
+ ;
+};
+
+// CSI Pc; Pt; Pl; Pb; Pr$ x
+// Fill Rectangular Area (DECFRA), VT420 and up.
+// Pc is the character to use.
+// Pt; Pl; Pb; Pr denotes the rectangle.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.fillRectangle = function(params) {
+ var ch = params[0]
+ , t = params[1]
+ , l = params[2]
+ , b = params[3]
+ , r = params[4];
+
+ var line
+ , i;
+
+ for (; t < b + 1; t++) {
+ line = this.lines[this.ybase + t];
+ for (i = l; i < r; i++) {
+ line[i] = [line[i][0], String.fromCharCode(ch)];
+ }
+ }
+
+ // this.maxRange();
+ this.updateRange(params[1]);
+ this.updateRange(params[3]);
+};
+
+// CSI Ps ; Pu ' z
+// Enable Locator Reporting (DECELR).
+// Valid values for the first parameter:
+// Ps = 0 -> Locator disabled (default).
+// Ps = 1 -> Locator enabled.
+// Ps = 2 -> Locator enabled for one report, then disabled.
+// The second parameter specifies the coordinate unit for locator
+// reports.
+// Valid values for the second parameter:
+// Pu = 0 <- or omitted -> default to character cells.
+// Pu = 1 <- device physical pixels.
+// Pu = 2 <- character cells.
+Terminal.prototype.enableLocatorReporting = function(params) {
+ var val = params[0] > 0;
+ //this.mouseEvents = val;
+ //this.decLocator = val;
+};
+
+// CSI Pt; Pl; Pb; Pr$ z
+// Erase Rectangular Area (DECERA), VT400 and up.
+// Pt; Pl; Pb; Pr denotes the rectangle.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.eraseRectangle = function(params) {
+ var t = params[0]
+ , l = params[1]
+ , b = params[2]
+ , r = params[3];
+
+ var line
+ , i
+ , ch;
+
+ ch = [this.eraseAttr(), ' ']; // xterm?
+
+ for (; t < b + 1; t++) {
+ line = this.lines[this.ybase + t];
+ for (i = l; i < r; i++) {
+ line[i] = ch;
+ }
+ }
+
+ // this.maxRange();
+ this.updateRange(params[0]);
+ this.updateRange(params[2]);
+};
+
+// CSI Pm ' {
+// Select Locator Events (DECSLE).
+// Valid values for the first (and any additional parameters)
+// are:
+// Ps = 0 -> only respond to explicit host requests (DECRQLP).
+// (This is default). It also cancels any filter
+// rectangle.
+// Ps = 1 -> report button down transitions.
+// Ps = 2 -> do not report button down transitions.
+// Ps = 3 -> report button up transitions.
+// Ps = 4 -> do not report button up transitions.
+Terminal.prototype.setLocatorEvents = function(params) {
+ ;
+};
+
+// CSI Pt; Pl; Pb; Pr$ {
+// Selective Erase Rectangular Area (DECSERA), VT400 and up.
+// Pt; Pl; Pb; Pr denotes the rectangle.
+Terminal.prototype.selectiveEraseRectangle = function(params) {
+ ;
+};
+
+// CSI Ps ' |
+// Request Locator Position (DECRQLP).
+// Valid values for the parameter are:
+// Ps = 0 , 1 or omitted -> transmit a single DECLRP locator
+// report.
+
+// If Locator Reporting has been enabled by a DECELR, xterm will
+// respond with a DECLRP Locator Report. This report is also
+// generated on button up and down events if they have been
+// enabled with a DECSLE, or when the locator is detected outside
+// of a filter rectangle, if filter rectangles have been enabled
+// with a DECEFR.
+
+// -> CSI Pe ; Pb ; Pr ; Pc ; Pp & w
+
+// Parameters are [event;button;row;column;page].
+// Valid values for the event:
+// Pe = 0 -> locator unavailable - no other parameters sent.
+// Pe = 1 -> request - xterm received a DECRQLP.
+// Pe = 2 -> left button down.
+// Pe = 3 -> left button up.
+// Pe = 4 -> middle button down.
+// Pe = 5 -> middle button up.
+// Pe = 6 -> right button down.
+// Pe = 7 -> right button up.
+// Pe = 8 -> M4 button down.
+// Pe = 9 -> M4 button up.
+// Pe = 1 0 -> locator outside filter rectangle.
+// ``button'' parameter is a bitmask indicating which buttons are
+// pressed:
+// Pb = 0 <- no buttons down.
+// Pb & 1 <- right button down.
+// Pb & 2 <- middle button down.
+// Pb & 4 <- left button down.
+// Pb & 8 <- M4 button down.
+// ``row'' and ``column'' parameters are the coordinates of the
+// locator position in the xterm window, encoded as ASCII deci-
+// mal.
+// The ``page'' parameter is not used by xterm, and will be omit-
+// ted.
+Terminal.prototype.requestLocatorPosition = function(params) {
+ ;
+};
+
+// CSI P m SP }
+// Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.insertColumns = function() {
+ var param = params[0]
+ , l = this.ybase + this.rows
+ , ch = [this.eraseAttr(), ' '] // xterm?
+ , i;
+
+ while (param--) {
+ for (i = this.ybase; i < l; i++) {
+ this.lines[i].splice(this.x + 1, 0, ch);
+ this.lines[i].pop();
+ }
+ }
+
+ this.maxRange();
+};
+
+// CSI P m SP ~
+// Delete P s Column(s) (default = 1) (DECDC), VT420 and up
+// NOTE: xterm doesn't enable this code by default.
+Terminal.prototype.deleteColumns = function() {
+ var param = params[0]
+ , l = this.ybase + this.rows
+ , ch = [this.eraseAttr(), ' '] // xterm?
+ , i;
+
+ while (param--) {
+ for (i = this.ybase; i < l; i++) {
+ this.lines[i].splice(this.x, 1);
+ this.lines[i].push(ch);
+ }
+ }
+
+ this.maxRange();
+};
+
+/**
+ * Prefix/Select/Visual/Search Modes
+ */
+
+Terminal.prototype.enterPrefix = function() {
+ this.prefixMode = true;
+};
+
+Terminal.prototype.leavePrefix = function() {
+ this.prefixMode = false;
+};
+
+Terminal.prototype.enterSelect = function() {
+ this._real = {
+ x: this.x,
+ y: this.y,
+ ydisp: this.ydisp,
+ ybase: this.ybase,
+ cursorHidden: this.cursorHidden,
+ lines: this.copyBuffer(this.lines),
+ write: this.write
+ };
+ this.write = function() {};
+ this.selectMode = true;
+ this.visualMode = false;
+ this.cursorHidden = false;
+ this.refresh(this.y, this.y);
+};
+
+Terminal.prototype.leaveSelect = function() {
+ this.x = this._real.x;
+ this.y = this._real.y;
+ this.ydisp = this._real.ydisp;
+ this.ybase = this._real.ybase;
+ this.cursorHidden = this._real.cursorHidden;
+ this.lines = this._real.lines;
+ this.write = this._real.write;
+ delete this._real;
+ this.selectMode = false;
+ this.visualMode = false;
+ this.refresh(0, this.rows - 1);
+};
+
+Terminal.prototype.enterVisual = function() {
+ this._real.preVisual = this.copyBuffer(this.lines);
+ this.selectText(this.x, this.x, this.ydisp + this.y, this.ydisp + this.y);
+ this.visualMode = true;
+};
+
+Terminal.prototype.leaveVisual = function() {
+ this.lines = this._real.preVisual;
+ delete this._real.preVisual;
+ delete this._selected;
+ this.visualMode = false;
+ this.refresh(0, this.rows - 1);
+};
+
+Terminal.prototype.enterSearch = function(down) {
+ this.entry = '';
+ this.searchMode = true;
+ this.searchDown = down;
+ this._real.preSearch = this.copyBuffer(this.lines);
+ this._real.preSearchX = this.x;
+ this._real.preSearchY = this.y;
+
+ var bottom = this.ydisp + this.rows - 1;
+ for (var i = 0; i < this.entryPrefix.length; i++) {
+ //this.lines[bottom][i][0] = (this.defAttr & ~0x1ff) | 4;
+ //this.lines[bottom][i][1] = this.entryPrefix[i];
+ this.lines[bottom][i] = [
+ (this.defAttr & ~0x1ff) | 4,
+ this.entryPrefix[i]
+ ];
+ }
+
+ this.y = this.rows - 1;
+ this.x = this.entryPrefix.length;
+
+ this.refresh(this.rows - 1, this.rows - 1);
+};
+
+Terminal.prototype.leaveSearch = function() {
+ this.searchMode = false;
+
+ if (this._real.preSearch) {
+ this.lines = this._real.preSearch;
+ this.x = this._real.preSearchX;
+ this.y = this._real.preSearchY;
+ delete this._real.preSearch;
+ delete this._real.preSearchX;
+ delete this._real.preSearchY;
+ }
+
+ this.refresh(this.rows - 1, this.rows - 1);
+};
+
+Terminal.prototype.copyBuffer = function(lines) {
+ var lines = lines || this.lines
+ , out = [];
+
+ for (var y = 0; y < lines.length; y++) {
+ out[y] = [];
+ for (var x = 0; x < lines[y].length; x++) {
+ out[y][x] = [lines[y][x][0], lines[y][x][1]];
+ }
+ }
+
+ return out;
+};
+
+Terminal.prototype.getCopyTextarea = function(text) {
+ var textarea = this._copyTextarea
+ , document = this.document;
+
+ if (!textarea) {
+ textarea = document.createElement('textarea');
+ textarea.style.position = 'absolute';
+ textarea.style.left = '-32000px';
+ textarea.style.top = '-32000px';
+ textarea.style.width = '0px';
+ textarea.style.height = '0px';
+ textarea.style.opacity = '0';
+ textarea.style.backgroundColor = 'transparent';
+ textarea.style.borderStyle = 'none';
+ textarea.style.outlineStyle = 'none';
+
+ document.getElementsByTagName('body')[0].appendChild(textarea);
+
+ this._copyTextarea = textarea;
+ }
+
+ return textarea;
+};
+
+// NOTE: Only works for primary selection on X11.
+// Non-X11 users should use Ctrl-C instead.
+Terminal.prototype.copyText = function(text) {
+ var self = this
+ , textarea = this.getCopyTextarea();
+
+ this.emit('copy', text);
+
+ textarea.focus();
+ textarea.textContent = text;
+ textarea.value = text;
+ textarea.setSelectionRange(0, text.length);
+
+ setTimeout(function() {
+ self.element.focus();
+ self.focus();
+ }, 1);
+};
+
+Terminal.prototype.selectText = function(x1, x2, y1, y2) {
+ var ox1
+ , ox2
+ , oy1
+ , oy2
+ , tmp
+ , x
+ , y
+ , xl
+ , attr;
+
+ if (this._selected) {
+ ox1 = this._selected.x1;
+ ox2 = this._selected.x2;
+ oy1 = this._selected.y1;
+ oy2 = this._selected.y2;
+
+ if (oy2 < oy1) {
+ tmp = ox2;
+ ox2 = ox1;
+ ox1 = tmp;
+ tmp = oy2;
+ oy2 = oy1;
+ oy1 = tmp;
+ }
+
+ if (ox2 < ox1 && oy1 === oy2) {
+ tmp = ox2;
+ ox2 = ox1;
+ ox1 = tmp;
+ }
+
+ for (y = oy1; y <= oy2; y++) {
+ x = 0;
+ xl = this.cols - 1;
+ if (y === oy1) {
+ x = ox1;
+ }
+ if (y === oy2) {
+ xl = ox2;
+ }
+ for (; x <= xl; x++) {
+ if (this.lines[y][x].old != null) {
+ //this.lines[y][x][0] = this.lines[y][x].old;
+ //delete this.lines[y][x].old;
+ attr = this.lines[y][x].old;
+ delete this.lines[y][x].old;
+ this.lines[y][x] = [attr, this.lines[y][x][1]];
+ }
+ }
+ }
+
+ y1 = this._selected.y1;
+ x1 = this._selected.x1;
+ }
+
+ y1 = Math.max(y1, 0);
+ y1 = Math.min(y1, this.ydisp + this.rows - 1);
+
+ y2 = Math.max(y2, 0);
+ y2 = Math.min(y2, this.ydisp + this.rows - 1);
+
+ this._selected = { x1: x1, x2: x2, y1: y1, y2: y2 };
+
+ if (y2 < y1) {
+ tmp = x2;
+ x2 = x1;
+ x1 = tmp;
+ tmp = y2;
+ y2 = y1;
+ y1 = tmp;
+ }
+
+ if (x2 < x1 && y1 === y2) {
+ tmp = x2;
+ x2 = x1;
+ x1 = tmp;
+ }
+
+ for (y = y1; y <= y2; y++) {
+ x = 0;
+ xl = this.cols - 1;
+ if (y === y1) {
+ x = x1;
+ }
+ if (y === y2) {
+ xl = x2;
+ }
+ for (; x <= xl; x++) {
+ //this.lines[y][x].old = this.lines[y][x][0];
+ //this.lines[y][x][0] &= ~0x1ff;
+ //this.lines[y][x][0] |= (0x1ff << 9) | 4;
+ attr = this.lines[y][x][0];
+ this.lines[y][x] = [
+ (attr & ~0x1ff) | ((0x1ff << 9) | 4),
+ this.lines[y][x][1]
+ ];
+ this.lines[y][x].old = attr;
+ }
+ }
+
+ y1 = y1 - this.ydisp;
+ y2 = y2 - this.ydisp;
+
+ y1 = Math.max(y1, 0);
+ y1 = Math.min(y1, this.rows - 1);
+
+ y2 = Math.max(y2, 0);
+ y2 = Math.min(y2, this.rows - 1);
+
+ //this.refresh(y1, y2);
+ this.refresh(0, this.rows - 1);
+};
+
+Terminal.prototype.grabText = function(x1, x2, y1, y2) {
+ var out = ''
+ , buf = ''
+ , ch
+ , x
+ , y
+ , xl
+ , tmp;
+
+ if (y2 < y1) {
+ tmp = x2;
+ x2 = x1;
+ x1 = tmp;
+ tmp = y2;
+ y2 = y1;
+ y1 = tmp;
+ }
+
+ if (x2 < x1 && y1 === y2) {
+ tmp = x2;
+ x2 = x1;
+ x1 = tmp;
+ }
+
+ for (y = y1; y <= y2; y++) {
+ x = 0;
+ xl = this.cols - 1;
+ if (y === y1) {
+ x = x1;
+ }
+ if (y === y2) {
+ xl = x2;
+ }
+ for (; x <= xl; x++) {
+ ch = this.lines[y][x][1];
+ if (ch === ' ') {
+ buf += ch;
+ continue;
+ }
+ if (buf) {
+ out += buf;
+ buf = '';
+ }
+ out += ch;
+ if (isWide(ch)) x++;
+ }
+ buf = '';
+ out += '\n';
+ }
+
+ // If we're not at the end of the
+ // line, don't add a newline.
+ for (x = x2, y = y2; x < this.cols; x++) {
+ if (this.lines[y][x][1] !== ' ') {
+ out = out.slice(0, -1);
+ break;
+ }
+ }
+
+ return out;
+};
+
+Terminal.prototype.keyPrefix = function(ev, key) {
+ if (key === 'k' || key === '&') {
+ this.destroy();
+ } else if (key === 'p' || key === ']') {
+ this.emit('request paste');
+ } else if (key === 'c') {
+ this.emit('request create');
+ } else if (key >= '0' && key <= '9') {
+ key = +key - 1;
+ if (!~key) key = 9;
+ this.emit('request term', key);
+ } else if (key === 'n') {
+ this.emit('request term next');
+ } else if (key === 'P') {
+ this.emit('request term previous');
+ } else if (key === ':') {
+ this.emit('request command mode');
+ } else if (key === '[') {
+ this.enterSelect();
+ }
+};
+
+Terminal.prototype.keySelect = function(ev, key) {
+ this.showCursor();
+
+ if (this.searchMode || key === 'n' || key === 'N') {
+ return this.keySearch(ev, key);
+ }
+
+ if (key === '\x04') { // ctrl-d
+ var y = this.ydisp + this.y;
+ if (this.ydisp === this.ybase) {
+ // Mimic vim behavior
+ this.y = Math.min(this.y + (this.rows - 1) / 2 | 0, this.rows - 1);
+ this.refresh(0, this.rows - 1);
+ } else {
+ this.scrollDisp((this.rows - 1) / 2 | 0);
+ }
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === '\x15') { // ctrl-u
+ var y = this.ydisp + this.y;
+ if (this.ydisp === 0) {
+ // Mimic vim behavior
+ this.y = Math.max(this.y - (this.rows - 1) / 2 | 0, 0);
+ this.refresh(0, this.rows - 1);
+ } else {
+ this.scrollDisp(-(this.rows - 1) / 2 | 0);
+ }
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === '\x06') { // ctrl-f
+ var y = this.ydisp + this.y;
+ this.scrollDisp(this.rows - 1);
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === '\x02') { // ctrl-b
+ var y = this.ydisp + this.y;
+ this.scrollDisp(-(this.rows - 1));
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === 'k' || key === '\x1b[A') {
+ var y = this.ydisp + this.y;
+ this.y--;
+ if (this.y < 0) {
+ this.y = 0;
+ this.scrollDisp(-1);
+ }
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y, this.y + 1);
+ }
+ return;
+ }
+
+ if (key === 'j' || key === '\x1b[B') {
+ var y = this.ydisp + this.y;
+ this.y++;
+ if (this.y >= this.rows) {
+ this.y = this.rows - 1;
+ this.scrollDisp(1);
+ }
+ if (this.visualMode) {
+ this.selectText(this.x, this.x, y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y - 1, this.y);
+ }
+ return;
+ }
+
+ if (key === 'h' || key === '\x1b[D') {
+ var x = this.x;
+ this.x--;
+ if (this.x < 0) {
+ this.x = 0;
+ }
+ if (this.visualMode) {
+ this.selectText(x, this.x, this.ydisp + this.y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y, this.y);
+ }
+ return;
+ }
+
+ if (key === 'l' || key === '\x1b[C') {
+ var x = this.x;
+ this.x++;
+ if (this.x >= this.cols) {
+ this.x = this.cols - 1;
+ }
+ if (this.visualMode) {
+ this.selectText(x, this.x, this.ydisp + this.y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y, this.y);
+ }
+ return;
+ }
+
+ if (key === 'v' || key === ' ') {
+ if (!this.visualMode) {
+ this.enterVisual();
+ } else {
+ this.leaveVisual();
+ }
+ return;
+ }
+
+ if (key === 'y') {
+ if (this.visualMode) {
+ var text = this.grabText(
+ this._selected.x1, this._selected.x2,
+ this._selected.y1, this._selected.y2);
+ this.copyText(text);
+ this.leaveVisual();
+ // this.leaveSelect();
+ }
+ return;
+ }
+
+ if (key === 'q' || key === '\x1b') {
+ if (this.visualMode) {
+ this.leaveVisual();
+ } else {
+ this.leaveSelect();
+ }
+ return;
+ }
+
+ if (key === 'w' || key === 'W') {
+ var ox = this.x;
+ var oy = this.y;
+ var oyd = this.ydisp;
+
+ var x = this.x;
+ var y = this.y;
+ var yb = this.ydisp;
+ var saw_space = false;
+
+ for (;;) {
+ var line = this.lines[yb + y];
+ while (x < this.cols) {
+ if (line[x][1] <= ' ') {
+ saw_space = true;
+ } else if (saw_space) {
+ break;
+ }
+ x++;
+ }
+ if (x >= this.cols) x = this.cols - 1;
+ if (x === this.cols - 1 && line[x][1] <= ' ') {
+ x = 0;
+ if (++y >= this.rows) {
+ y--;
+ if (++yb > this.ybase) {
+ yb = this.ybase;
+ x = this.x;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+
+ this.x = x, this.y = y;
+ this.scrollDisp(-this.ydisp + yb);
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === 'b' || key === 'B') {
+ var ox = this.x;
+ var oy = this.y;
+ var oyd = this.ydisp;
+
+ var x = this.x;
+ var y = this.y;
+ var yb = this.ydisp;
+
+ for (;;) {
+ var line = this.lines[yb + y];
+ var saw_space = x > 0 && line[x][1] > ' ' && line[x - 1][1] > ' ';
+ while (x >= 0) {
+ if (line[x][1] <= ' ') {
+ if (saw_space && (x + 1 < this.cols && line[x + 1][1] > ' ')) {
+ x++;
+ break;
+ } else {
+ saw_space = true;
+ }
+ }
+ x--;
+ }
+ if (x < 0) x = 0;
+ if (x === 0 && (line[x][1] <= ' ' || !saw_space)) {
+ x = this.cols - 1;
+ if (--y < 0) {
+ y++;
+ if (--yb < 0) {
+ yb++;
+ x = 0;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+
+ this.x = x, this.y = y;
+ this.scrollDisp(-this.ydisp + yb);
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === 'e' || key === 'E') {
+ var x = this.x + 1;
+ var y = this.y;
+ var yb = this.ydisp;
+ if (x >= this.cols) x--;
+
+ for (;;) {
+ var line = this.lines[yb + y];
+ while (x < this.cols) {
+ if (line[x][1] <= ' ') {
+ x++;
+ } else {
+ break;
+ }
+ }
+ while (x < this.cols) {
+ if (line[x][1] <= ' ') {
+ if (x - 1 >= 0 && line[x - 1][1] > ' ') {
+ x--;
+ break;
+ }
+ }
+ x++;
+ }
+ if (x >= this.cols) x = this.cols - 1;
+ if (x === this.cols - 1 && line[x][1] <= ' ') {
+ x = 0;
+ if (++y >= this.rows) {
+ y--;
+ if (++yb > this.ybase) {
+ yb = this.ybase;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+
+ this.x = x, this.y = y;
+ this.scrollDisp(-this.ydisp + yb);
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === '^' || key === '0') {
+ var ox = this.x;
+
+ if (key === '0') {
+ this.x = 0;
+ } else if (key === '^') {
+ var line = this.lines[this.ydisp + this.y];
+ var x = 0;
+ while (x < this.cols) {
+ if (line[x][1] > ' ') {
+ break;
+ }
+ x++;
+ }
+ if (x >= this.cols) x = this.cols - 1;
+ this.x = x;
+ }
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, this.ydisp + this.y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y, this.y);
+ }
+ return;
+ }
+
+ if (key === '$') {
+ var ox = this.x;
+ var line = this.lines[this.ydisp + this.y];
+ var x = this.cols - 1;
+ while (x >= 0) {
+ if (line[x][1] > ' ') {
+ if (this.visualMode && x < this.cols - 1) x++;
+ break;
+ }
+ x--;
+ }
+ if (x < 0) x = 0;
+ this.x = x;
+ if (this.visualMode) {
+ this.selectText(ox, this.x, this.ydisp + this.y, this.ydisp + this.y);
+ } else {
+ this.refresh(this.y, this.y);
+ }
+ return;
+ }
+
+ if (key === 'g' || key === 'G') {
+ var ox = this.x;
+ var oy = this.y;
+ var oyd = this.ydisp;
+ if (key === 'g') {
+ this.x = 0, this.y = 0;
+ this.scrollDisp(-this.ydisp);
+ } else if (key === 'G') {
+ this.x = 0, this.y = this.rows - 1;
+ this.scrollDisp(this.ybase);
+ }
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === 'H' || key === 'M' || key === 'L') {
+ var ox = this.x;
+ var oy = this.y;
+ if (key === 'H') {
+ this.x = 0, this.y = 0;
+ } else if (key === 'M') {
+ this.x = 0, this.y = this.rows / 2 | 0;
+ } else if (key === 'L') {
+ this.x = 0, this.y = this.rows - 1;
+ }
+ if (this.visualMode) {
+ this.selectText(ox, this.x, this.ydisp + oy, this.ydisp + this.y);
+ } else {
+ this.refresh(oy, oy);
+ this.refresh(this.y, this.y);
+ }
+ return;
+ }
+
+ if (key === '{' || key === '}') {
+ var ox = this.x;
+ var oy = this.y;
+ var oyd = this.ydisp;
+
+ var line;
+ var saw_full = false;
+ var found = false;
+ var first_is_space = -1;
+ var y = this.y + (key === '{' ? -1 : 1);
+ var yb = this.ydisp;
+ var i;
+
+ if (key === '{') {
+ if (y < 0) {
+ y++;
+ if (yb > 0) yb--;
+ }
+ } else if (key === '}') {
+ if (y >= this.rows) {
+ y--;
+ if (yb < this.ybase) yb++;
+ }
+ }
+
+ for (;;) {
+ line = this.lines[yb + y];
+
+ for (i = 0; i < this.cols; i++) {
+ if (line[i][1] > ' ') {
+ if (first_is_space === -1) {
+ first_is_space = 0;
+ }
+ saw_full = true;
+ break;
+ } else if (i === this.cols - 1) {
+ if (first_is_space === -1) {
+ first_is_space = 1;
+ } else if (first_is_space === 0) {
+ found = true;
+ } else if (first_is_space === 1) {
+ if (saw_full) found = true;
+ }
+ break;
+ }
+ }
+
+ if (found) break;
+
+ if (key === '{') {
+ y--;
+ if (y < 0) {
+ y++;
+ if (yb > 0) yb--;
+ else break;
+ }
+ } else if (key === '}') {
+ y++;
+ if (y >= this.rows) {
+ y--;
+ if (yb < this.ybase) yb++;
+ else break;
+ }
+ }
+ }
+
+ if (!found) {
+ if (key === '{') {
+ y = 0;
+ yb = 0;
+ } else if (key === '}') {
+ y = this.rows - 1;
+ yb = this.ybase;
+ }
+ }
+
+ this.x = 0, this.y = y;
+ this.scrollDisp(-this.ydisp + yb);
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ if (key === '/' || key === '?') {
+ if (!this.visualMode) {
+ this.enterSearch(key === '/');
+ }
+ return;
+ }
+
+ return false;
+};
+
+Terminal.prototype.keySearch = function(ev, key) {
+ if (key === '\x1b') {
+ this.leaveSearch();
+ return;
+ }
+
+ if (key === '\r' || (!this.searchMode && (key === 'n' || key === 'N'))) {
+ this.leaveSearch();
+
+ var entry = this.entry;
+
+ if (!entry) {
+ this.refresh(0, this.rows - 1);
+ return;
+ }
+
+ var ox = this.x;
+ var oy = this.y;
+ var oyd = this.ydisp;
+
+ var line;
+ var found = false;
+ var wrapped = false;
+ var x = this.x + 1;
+ var y = this.ydisp + this.y;
+ var yb, i;
+ var up = key === 'N'
+ ? this.searchDown
+ : !this.searchDown;
+
+ for (;;) {
+ line = this.lines[y];
+
+ while (x < this.cols) {
+ for (i = 0; i < entry.length; i++) {
+ if (x + i >= this.cols) break;
+ if (line[x + i][1] !== entry[i]) {
+ break;
+ } else if (line[x + i][1] === entry[i] && i === entry.length - 1) {
+ found = true;
+ break;
+ }
+ }
+ if (found) break;
+ x += i + 1;
+ }
+ if (found) break;
+
+ x = 0;
+
+ if (!up) {
+ y++;
+ if (y > this.ybase + this.rows - 1) {
+ if (wrapped) break;
+ // this.setMessage('Search wrapped. Continuing at TOP.');
+ wrapped = true;
+ y = 0;
+ }
+ } else {
+ y--;
+ if (y < 0) {
+ if (wrapped) break;
+ // this.setMessage('Search wrapped. Continuing at BOTTOM.');
+ wrapped = true;
+ y = this.ybase + this.rows - 1;
+ }
+ }
+ }
+
+ if (found) {
+ if (y - this.ybase < 0) {
+ yb = y;
+ y = 0;
+ if (yb > this.ybase) {
+ y = yb - this.ybase;
+ yb = this.ybase;
+ }
+ } else {
+ yb = this.ybase;
+ y -= this.ybase;
+ }
+
+ this.x = x, this.y = y;
+ this.scrollDisp(-this.ydisp + yb);
+
+ if (this.visualMode) {
+ this.selectText(ox, this.x, oy + oyd, this.ydisp + this.y);
+ }
+ return;
+ }
+
+ // this.setMessage("No matches found.");
+ this.refresh(0, this.rows - 1);
+
+ return;
+ }
+
+ if (key === '\b' || key === '\x7f') {
+ if (this.entry.length === 0) return;
+ var bottom = this.ydisp + this.rows - 1;
+ this.entry = this.entry.slice(0, -1);
+ var i = this.entryPrefix.length + this.entry.length;
+ //this.lines[bottom][i][1] = ' ';
+ this.lines[bottom][i] = [
+ this.lines[bottom][i][0],
+ ' '
+ ];
+ this.x--;
+ this.refresh(this.rows - 1, this.rows - 1);
+ this.refresh(this.y, this.y);
+ return;
+ }
+
+ if (key.length === 1 && key >= ' ' && key <= '~') {
+ var bottom = this.ydisp + this.rows - 1;
+ this.entry += key;
+ var i = this.entryPrefix.length + this.entry.length - 1;
+ //this.lines[bottom][i][0] = (this.defAttr & ~0x1ff) | 4;
+ //this.lines[bottom][i][1] = key;
+ this.lines[bottom][i] = [
+ (this.defAttr & ~0x1ff) | 4,
+ key
+ ];
+ this.x++;
+ this.refresh(this.rows - 1, this.rows - 1);
+ this.refresh(this.y, this.y);
+ return;
+ }
+
+ return false;
+};
+
+/**
+ * Character Sets
+ */
+
+Terminal.charsets = {};
+
+// DEC Special Character and Line Drawing Set.
+// http://vt100.net/docs/vt102-ug/table5-13.html
+// A lot of curses apps use this if they see TERM=xterm.
+// testing: echo -e '\e(0a\e(B'
+// The xterm output sometimes seems to conflict with the
+// reference above. xterm seems in line with the reference
+// when running vttest however.
+// The table below now uses xterm's output from vttest.
+Terminal.charsets.SCLD = { // (0
+ '`': '\u25c6', // 'â—†'
+ 'a': '\u2592', // 'â–’'
+ 'b': '\u0009', // '\t'
+ 'c': '\u000c', // '\f'
+ 'd': '\u000d', // '\r'
+ 'e': '\u000a', // '\n'
+ 'f': '\u00b0', // '°'
+ 'g': '\u00b1', // '±'
+ 'h': '\u2424', // '\u2424' (NL)
+ 'i': '\u000b', // '\v'
+ 'j': '\u2518', // '┘'
+ 'k': '\u2510', // 'â”'
+ 'l': '\u250c', // '┌'
+ 'm': '\u2514', // 'â””'
+ 'n': '\u253c', // '┼'
+ 'o': '\u23ba', // '⎺'
+ 'p': '\u23bb', // '⎻'
+ 'q': '\u2500', // '─'
+ 'r': '\u23bc', // '⎼'
+ 's': '\u23bd', // '⎽'
+ 't': '\u251c', // '├'
+ 'u': '\u2524', // '┤'
+ 'v': '\u2534', // 'â”´'
+ 'w': '\u252c', // '┬'
+ 'x': '\u2502', // '│'
+ 'y': '\u2264', // '≤'
+ 'z': '\u2265', // '≥'
+ '{': '\u03c0', // 'Ï€'
+ '|': '\u2260', // '≠'
+ '}': '\u00a3', // '£'
+ '~': '\u00b7' // '·'
+};
+
+Terminal.charsets.UK = null; // (A
+Terminal.charsets.US = null; // (B (USASCII)
+Terminal.charsets.Dutch = null; // (4
+Terminal.charsets.Finnish = null; // (C or (5
+Terminal.charsets.French = null; // (R
+Terminal.charsets.FrenchCanadian = null; // (Q
+Terminal.charsets.German = null; // (K
+Terminal.charsets.Italian = null; // (Y
+Terminal.charsets.NorwegianDanish = null; // (E or (6
+Terminal.charsets.Spanish = null; // (Z
+Terminal.charsets.Swedish = null; // (H or (7
+Terminal.charsets.Swiss = null; // (=
+Terminal.charsets.ISOLatin = null; // /A
+
+/**
+ * Helpers
+ */
+
+function on(el, type, handler, capture) {
+ el.addEventListener(type, handler, capture || false);
+}
+
+function off(el, type, handler, capture) {
+ el.removeEventListener(type, handler, capture || false);
+}
+
+function cancel(ev) {
+ if (ev.preventDefault) ev.preventDefault();
+ ev.returnValue = false;
+ if (ev.stopPropagation) ev.stopPropagation();
+ ev.cancelBubble = true;
+ return false;
+}
+
+function inherits(child, parent) {
+ function f() {
+ this.constructor = child;
+ }
+ f.prototype = parent.prototype;
+ child.prototype = new f;
+}
+
+// if bold is broken, we can't
+// use it in the terminal.
+function isBoldBroken(document) {
+ var body = document.getElementsByTagName('body')[0];
+ var terminal = document.createElement('div');
+ terminal.className = 'terminal';
+ var line = document.createElement('div');
+ var el = document.createElement('span');
+ el.innerHTML = 'hello world';
+ line.appendChild(el);
+ terminal.appendChild(line);
+ body.appendChild(terminal);
+ var w1 = el.scrollWidth;
+ el.style.fontWeight = 'bold';
+ var w2 = el.scrollWidth;
+ body.removeChild(terminal);
+ return w1 !== w2;
+}
+
+var String = this.String;
+var setTimeout = this.setTimeout;
+var setInterval = this.setInterval;
+
+function indexOf(obj, el) {
+ var i = obj.length;
+ while (i--) {
+ if (obj[i] === el) return i;
+ }
+ return -1;
+}
+
+function isWide(ch) {
+ if (ch <= '\uff00') return false;
+ return (ch >= '\uff01' && ch <= '\uffbe')
+ || (ch >= '\uffc2' && ch <= '\uffc7')
+ || (ch >= '\uffca' && ch <= '\uffcf')
+ || (ch >= '\uffd2' && ch <= '\uffd7')
+ || (ch >= '\uffda' && ch <= '\uffdc')
+ || (ch >= '\uffe0' && ch <= '\uffe6')
+ || (ch >= '\uffe8' && ch <= '\uffee');
+}
+
+function matchColor(r1, g1, b1) {
+ var hash = (r1 << 16) | (g1 << 8) | b1;
+
+ if (matchColor._cache[hash] != null) {
+ return matchColor._cache[hash];
+ }
+
+ var ldiff = Infinity
+ , li = -1
+ , i = 0
+ , c
+ , r2
+ , g2
+ , b2
+ , diff;
+
+ for (; i < Terminal.vcolors.length; i++) {
+ c = Terminal.vcolors[i];
+ r2 = c[0];
+ g2 = c[1];
+ b2 = c[2];
+
+ diff = matchColor.distance(r1, g1, b1, r2, g2, b2);
+
+ if (diff === 0) {
+ li = i;
+ break;
+ }
+
+ if (diff < ldiff) {
+ ldiff = diff;
+ li = i;
+ }
+ }
+
+ return matchColor._cache[hash] = li;
+}
+
+matchColor._cache = {};
+
+// http://stackoverflow.com/questions/1633828
+matchColor.distance = function(r1, g1, b1, r2, g2, b2) {
+ return Math.pow(30 * (r1 - r2), 2)
+ + Math.pow(59 * (g1 - g2), 2)
+ + Math.pow(11 * (b1 - b2), 2);
+};
+
+function each(obj, iter, con) {
+ if (obj.forEach) return obj.forEach(iter, con);
+ for (var i = 0; i < obj.length; i++) {
+ iter.call(con, obj[i], i, obj);
+ }
+}
+
+function keys(obj) {
+ if (Object.keys) return Object.keys(obj);
+ var key, keys = [];
+ for (key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ keys.push(key);
+ }
+ }
+ return keys;
+}
+
+/**
+ * Expose
+ */
+
+Terminal.EventEmitter = EventEmitter;
+Terminal.Stream = Stream;
+Terminal.inherits = inherits;
+Terminal.on = on;
+Terminal.off = off;
+Terminal.cancel = cancel;
+
+if (typeof module !== 'undefined') {
+ module.exports = Terminal;
+} else {
+ this.Terminal = Terminal;
+}
+
+}).call(function() {
+ return this || (typeof window !== 'undefined' ? window : global);
+}());
--
1.9.1
More information about the Kimchi-devel
mailing list