How to fix UTF-8 encoding for the entire ENiGMA½ BBS system

[gatokichi]

I understand that ENiGMA½ BBS prioritizes ANSI display compatibility. However, in my country's language, switching between ANSI(cp437) and UTF-8 can cause characters, especially full-width ones, to be displayed incorrectly, resulting in garbled text. Even if I re-specify the encoding in the terminal, the display may not be corrected. I believe this issue also affects Chinese characters, Japanese Kana, Korean Hangul, and other non-alphabetic scripts.
Is there a way to disable the switching between ANSI and UTF-8 and fix the encoding to UTF-8 for the entire ENiGMA½ BBS system (for all users)?

{"name":"ENiGMA½ BBS","hostname":"host","pid":21238,"level":20,"encoding":"cp437","msg":"Terminal type changed to xterm-256color; Adjusting output encoding","time":"2025-01-26T03:41:53.625Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":21238,"level":30,"encoding":"utf8","currentEncoding":"cp437","msg":"Output encoding changed to utf8","time":"2025-01-26T03:41:53.626Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":21238,"nodeId":1,"sessionId":"IdIdIdIdId","level":20,"termType":"XTERM-256COLOR","msg":"Set terminal type","time":"2025-01-26T03:41:53.626Z","v":0}


{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"level":20,"encoding":"cp437","msg":"Terminal type changed to xterm-256color; Adjusting output encoding","time":"2025-01-26T02:19:20.760Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"level":30,"encoding":"utf8","currentEncoding":"cp437","msg":"Output encoding changed to utf8","time":"2025-01-26T02:19:20.762Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"nodeId":1,"sessionId":"ppUrKg6QrEK","level":30,"msg":"Terminal identified as UTF-8 but does not appear to be. Overriding to \"ansi\".","time":"2025-01-26T02:19:20.842Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"level":20,"encoding":"utf8","msg":"Terminal type changed to ansi; Adjusting output encoding","time":"2025-01-26T02:19:20.843Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"level":30,"encoding":"cp437","currentEncoding":"utf8","msg":"Output encoding changed to cp437","time":"2025-01-26T02:19:20.843Z","v":0}
{"name":"ENiGMA½ BBS","hostname":"host","pid":20955,"nodeId":1,"sessionId":"IdIdIdIdId","level":20,"termType":"ansi","msg":"Set terminal type","time":"2025-01-26T02:19:20.843Z","v":0}

[cognitivegears]

Hi @gatokichi - I believe that you should be able to do this today, though will take a bit of customization.

First you will need to save your art files in utf-8. Most of the modern ANSI art programs should be able to do this, I'm pretty sure IcyDraw can for example.

Then in the menus config use the "encodedAs" option to tell it that the art file is in utf-8 (unfortunately, I don't see that it is documented though it should be, but if you are comfortable looking at code, you can see more details at:

enigma-bbs/core/art.js

Line 89 in 6766f6e

// Convert from encodedAs -> j

).

After that, change your menu config to force the connection to utf-8 using the setClientEncoding systemMethod - see https://nuskooler.github.io/enigma-bbs/configuration/menu-hjson.html for info on that.

Hopefully, that should force everything into utf-8 and fix the issues you are seeing. Hope this helps!

[gatokichi]

@cognitivegears Thank you.
First, I will start by creating the art files in UTF-8.
I also want to make it possible to enforce UTF-8 in the menu config.
Since I'm not yet familiar with the ENiGMA½ BBS system, I think it will take some time, but I plan to solve the issues one by one.

[cognitivegears]

@cognitivegears Thank you.

First, I will start by creating the art files in UTF-8.

I also want to make it possible to enforce UTF-8 in the menu config.

Since I'm not yet familiar with the ENiGMA½ BBS system, I think it will take some time, but I plan to solve the issues one by one.

Sounds good - if I can suggest, maybe just start with the login screen and maybe one or two post login. Once you get the config working for that you can be sure of what's needed before doing for the rest of the art. Let us know if you run into any troubles!

[NuSkooler]

@gatokichi I love that Enig is being used in a non-Romanized language! As @cognitivegears says, you could force all menus to UTF-8, and if needed, also save all art as UTF-8.

Enigma will read all ANSI file as CP437 and convert to the clients encoding of UTF-8 if needed. Perhaps a small PR could set some global enforcement such as forceOututEncoding: utf8 or whatever.

If @cognitivegears' suggestions work for you, that will give some information as to what we could do here to make things easier.

[cognitivegears]

Exactly, that would be nice. I wonder if instead of a global enforcement, we could either/both of:

1. look for a utf-8 BOM (at least I think that should work, FEFF shouldn't be a valid CP437 sequence I believe,) or
2. use a file extension, in the art.js, SUPPORTED_ART_TYPES, some ideas: .ans8 / '.u8ansi, and .utf8instead of.asc` for plain utf-8 files, for example

Downside to 1) is that I'm not sure whether the modern ansi editors can save a BOM, and anyway BOM has gone out of style generally, so I'm inclined to just use extension version. The reason I'd think that instead of global enforcement is that I could see someone wanting to support both (a multi-lingual BBS for example, or as a second option for languages that have a romanized version and want to support either native encoding or the romanized for, say, old bbs terminal programs.)

EDIT: thinking some more, there is also an option 3) Create the forceOutputEncoding: utf8, but do it at the theme level, that way you could still support multiple - though I still like 1) and 2) better generally I think just for ease of use

[gatokichi]

The method of registering extensions for UTF-8 in the proposed SUPPORTED_ART_TYPES seemed appealing, but we decided not to adopt it this time since it is uncertain which one would be used depending on the user's environment.

Simply adding encodedAs: "utf-8" to /config/menus/*.hjson resolved the issue of garbled text in the menu screen.

exp: {
    ****: ****
    config {
        ****: ****
        encodedAs: "utf-8"
    }
}

However, when using double-width characters such as Chinese, Japanese, or Korean in ART files, the position of the characters following the control characters to the right shifts to the left. This can be prevented by positioning the text further to the right to compensate for the shift, but fixing it can be a bit troublesome.

[gatokichi]

I am continuing to work on converting the menu screen to UTF-8.
In config/menus/mybbs-main.hjson, the encodedAs setting works when art and config are at the same hierarchy level. However, if art is inside config, encodedAs becomes ineffective. I assume this is expected due to the difference in hierarchy, but how should I write it to enable encodedAs in this case?

{
    menus: {
        exp1: {
            desc: exp1
            module: exp1
            art: EXP1
            config: {
                encodedAs: "utf-8"            // OK
            }
        }

        exp2: {
            desc: exp2
            module: exp2
            config: {
                art: {
                    hogeA: EXP2a
                    hogeB: EXP2b
                }
                encodedAs: "utf-8"            // NG
            }
        }
    }
}

[NuSkooler]

Hi @gatokichi! In your example above, I'm assuming you're using different module's, is that correct?

I'm wondering if there are differences in the way art is loaded between them.

[gatokichi]

Yes, it shows menu items that use different modules. For example, in the following case:

mainMenuSystemStats: {  
    desc: System Stats  
    art: SYSSTAT  
    config: {  
        pause: true  
        encodedAs: "utf-8"  
    }  
}  

In this case, SYSSTAT.ans is displayed encoded in UTF-8.

mainMenuFeedbackToSysOp: {  
    desc: SysOp Feedback  
    module: msg_area_post_fse  
    config: {  
        art: {  
            header: MSGEHDR  
            body: MSGBODY  
            footerEditor: MSGEFTR  
            footerEditorMenu: MSGEMFT  
            help: MSGEHLP  
        },  
        editorMode: edit  
        editorType: email  
        messageAreaTag: private_mail  
        toUserId: 1 /* always to +op */  
        encodedAs: "utf-8"  
    }  
    .............
}  

In this case, MSGEHDR.ans, MSGBODY.ans, MSGEFTR.ans, MSGEMFT.ans and MSGEHLP.ans will have garbled UTF-8 characters.

I thought that the hierarchy of art and config was important, but does module also affect this?

I couldn’t find a perfect way to specify UTF-8 encoding in menu.hjson, so I handled it by making a rough and messy change to core/art.js. This is not the correct way to fix it, so I wouldn’t recommend it to others.

function getArtFromPath(path, options, cb) {
    fs.readFile(path, (err, data) => {
        if (err) {
            return cb(err);
        }

        //
        //  Convert from encodedAs -> j
        //
        const ext = paths.extname(path).toLowerCase();
        const encoding = "utf-8";
        //const encoding = options.encodedAs || defaultEncodingFromExtension(ext);

However, since all art files no longer have garbled UTF-8 characters, I’m satisfied with how the menu display turned out. Additionally, the config: { encodedAs: "utf-8" } in the menu files is no longer necessary.

That said, another issue remains: when entering double-width characters in the message body, the cursor moves only by a single-width space, causing the characters to temporarily overlap, like slate roof tiles.

More than 30 years ago, CP437 ANSI art couldn’t be displayed properly in my country’s CP932 screen mode, and many BBS host programs failed to handle my country’s two-byte characters (Shift-JIS, EUC encoding) in FIDO message exchanges, causing garbled text. I struggled with it back then, and I never thought I’d be dealing with encoding issues again. However, this struggle feels nostalgic, and I’m currently enjoying it a bit.

[gatokichi]

In ENiGMA½, there is no control over full-width characters (especially CJK characters) during text input. When attempting to delete a full-width character using the backspace key, only the equivalent of a half-width character is removed, causing the input text to become corrupted. This issue is present even with single-line input, but it becomes particularly critical when editing text in the screen editor used for message composition, where existing text can be irreparably damaged.

To address this, I have modified core/edit_text_view.js, which controls single-line input, and core/multi_line_edit_text_view.js, which handles text input in the screen editor.

These modifications work correctly when inputting CJK characters in UTF-8, but I lack the knowledge to ensure compatibility with scripts such as Arabic, so those are likely unsupported.

Since ENiGMA½ is probably intended primarily for users working with alphanumeric characters, I do not believe my modifications need to be officially adopted, so I am simply sharing them here.

While it might be possible to directly write character code ranges in the source to determine character width, I chose to use the wcwidth module instead.

To install the wcwidth module, run:
npm install wcwidth

core/edit_text_view.js (full)

/* jslint node: true */
'use strict';

const wcwidth = require('wcwidth');

//  ENiGMA½
const TextView = require('./text_view.js').TextView;
const miscUtil = require('./misc_util.js');
const strUtil = require('./string_util.js');

const VIEW_SPECIAL_KEY_MAP_DEFAULT = require('./view').VIEW_SPECIAL_KEY_MAP_DEFAULT;

//  deps
const _ = require('lodash');

exports.EditTextView = EditTextView;

const EDIT_TEXT_VIEW_KEY_MAP = Object.assign({}, VIEW_SPECIAL_KEY_MAP_DEFAULT, {
    delete: ['delete', 'ctrl + d'], //  https://www.tecmint.com/linux-command-line-bash-shortcut-keys/
});

function EditTextView(options) {
    options.acceptsFocus = miscUtil.valueWithDefault(options.acceptsFocus, true);
    options.acceptsInput = miscUtil.valueWithDefault(options.acceptsInput, true);
    options.cursorStyle = miscUtil.valueWithDefault(options.cursorStyle, 'steady block');
    options.resizable = false;

    if (!_.isObject(options.specialKeyMap)) {
        options.specialKeyMap = EDIT_TEXT_VIEW_KEY_MAP;
    }

    TextView.call(this, options);

    this.initDefaultWidth();
    this.cursorPos = { row: 0, col: 0 };
    this.wcwidth = wcwidth;

    this.getDisplayWidth = function (text) {
        return this.wcwidth(text);
    };

    this.clientBackspace = function () {
        if (this.text.length > 0) {
            const lastChar = this.text.slice(-1);
            const charWidth = this.getDisplayWidth(lastChar);
            this.text = this.text.substr(0, this.text.length - 1);

            if (this.text.length >= this.dimens.width) {
                this.redraw();
            } else {
                this.cursorPos.col -= 1;
                if (this.cursorPos.col >= 0) {
                    const fillCharSGR = this.getStyleSGR(1) || this.getSGR();
                    const backspaces = '\b'.repeat(charWidth);
                    const fillSpaces = this.fillChar.repeat(charWidth);
                    this.client.term.write(
                        `${backspaces}${fillCharSGR}${fillSpaces}${backspaces}${this.getFocusSGR()}`
                    );
                }
            }
        }
    };
}

require('util').inherits(EditTextView, TextView);

EditTextView.prototype.onKeyPress = function (ch, key) {
    if (key) {
        if (this.isKeyMapped('backspace', key.name)) {
            if (this.text.length > 0) {
                this.clientBackspace();
            }

            return EditTextView.super_.prototype.onKeyPress.call(this, ch, key);
        } else if (this.isKeyMapped('delete', key.name)) {
            //  Some (mostly older) terms send 'delete' for Backspace.
            //  if we're at the end of the line, go ahead and treat them the same
            if (this.text.length > 0 && this.cursorPos.col === this.text.length) {
                this.clientBackspace();
            }
        } else if (this.isKeyMapped('clearLine', key.name)) {
            this.text = '';
            this.cursorPos.col = 0;
            this.setFocus(true); //  resetting focus will redraw & adjust cursor

            return EditTextView.super_.prototype.onKeyPress.call(this, ch, key);
        }
    }

    if (ch && strUtil.isPrintable(ch)) {
        if (this.text.length < this.maxLength) {
            ch = strUtil.stylizeString(ch, this.textStyle);

            this.text += ch;

            if (this.text.length > this.dimens.width) {
                //  no shortcuts - redraw the view
                this.redraw();
            } else {
                this.cursorPos.col += 1;

                if (_.isString(this.textMaskChar) && this.textMaskChar.length > 0) {
                    this.client.term.write(this.textMaskChar);
                } else {
                    this.client.term.write(ch);
                }
            }
        }
    }

    EditTextView.super_.prototype.onKeyPress.call(this, ch, key);
};

EditTextView.prototype.setText = function (text) {
    //  draw & set |text|
    EditTextView.super_.prototype.setText.call(this, text);

    //  adjust local cursor tracking
    this.cursorPos = { row: 0, col: text.length };
};

[gatokichi]

The changes to the screen editor were extensive. I have also added features to merge lines when pressing the delete key at the end of a line and to connect to the previous line when pressing the backspace key at the beginning of a line.

core/multi_line_edit_text_view.js (full)

/* jslint node: true */
'use strict';

const wcwidth = require('wcwidth');

const View = require('./view.js').View;
const strUtil = require('./string_util.js');
const ansi = require('./ansi_term.js');
const wordWrapText = require('./word_wrap.js').wordWrapText;
const ansiPrep = require('./ansi_prep.js');

const assert = require('assert');
const _ = require('lodash');

//  :TODO: Determine CTRL-* keys for various things
//  See http://www.bbsdocumentary.com/library/PROGRAMS/GRAPHICS/ANSI/bansi.txt
//  http://wiki.synchro.net/howto:editor:slyedit#edit_mode
//  http://sublime-text-unofficial-documentation.readthedocs.org/en/latest/reference/keyboard_shortcuts_win.html

/* Mystic
     [^B]  Reformat Paragraph            [^O]  Show this help file
       [^I]  Insert tab space              [^Q]  Enter quote mode
       [^K]  Cut current line of text      [^V]  Toggle insert/overwrite
       [^U]  Paste previously cut text     [^Y]  Delete current line


                            BASIC MOVEMENT COMMANDS

                  UP/^E       LEFT/^S      PGUP/^R      HOME/^F
                DOWN/^X      RIGHT/^D      PGDN/^C       END/^G
*/

//
//  Some other interesting implementations, resources, etc.
//
//  Editors - BBS
//  *   https://github.com/M-griffin/Enthral/blob/master/src/msg_fse.cpp
//
//
//  Editors - Other
//  *   http://joe-editor.sourceforge.net/
//  *   http://www.jbox.dk/downloads/edit.c
//  *   https://github.com/dominictarr/hipster
//
//  Implementations - Word Wrap
//  *   https://github.com/protomouse/synchronet/blob/93b01c55b3102ebc3c4f4793c3a45b8c13d0dc2a/src/sbbs3/wordwrap.c
//
//  Misc notes
//  * https://github.com/dominictarr/hipster/issues/15 (Deleting lines/etc.)
//
//  Blessed
//      insertLine: CSR(top, bottom) + CUP(y, 0) + IL(1) + CSR(0, height)
//      deleteLine: CSR(top, bottom) + CUP(y, 0) + DL(1) + CSR(0, height)
//  Quick Ansi -- update only what was changed:
//  https://github.com/dominictarr/quickansi

//
//  To-Do
//
//  * Index pos % for emit scroll events
//  * Some of this should be async'd where there is lots of processing (e.g. word wrap)
//  * Fix backspace when col=0 (e.g. bs to prev line)
//  * Add word delete (CTRL+????)
//  *

const SPECIAL_KEY_MAP_DEFAULT = {
    'line feed': ['return'],
    exit: ['esc'],
    backspace: ['backspace', 'ctrl + d'], //  https://www.tecmint.com/linux-command-line-bash-shortcut-keys/
    delete: ['delete'],
    tab: ['tab'],
    up: ['up arrow'],
    down: ['down arrow'],
    end: ['end'],
    home: ['home'],
    left: ['left arrow'],
    right: ['right arrow'],
    'delete line': ['ctrl + y', 'ctrl + u'], //  https://en.wikipedia.org/wiki/Backspace
    'page up': ['page up'],
    'page down': ['page down'],
    insert: ['insert', 'ctrl + v'],
};

exports.MultiLineEditTextView = MultiLineEditTextView;

function MultiLineEditTextView(options) {
    if (!_.isBoolean(options.acceptsFocus)) {
        options.acceptsFocus = true;
    }

    if (!_.isBoolean(this.acceptsInput)) {
        options.acceptsInput = true;
    }

    if (!_.isObject(options.specialKeyMap)) {
        options.specialKeyMap = SPECIAL_KEY_MAP_DEFAULT;
    }

    View.call(this, options);

    this.initDefaultWidth();

    var self = this;

        this.wcwidth = wcwidth;

    this.getDisplayWidth = function (text) {
        return self.wcwidth(text);
    };

    this.getCursorDisplayCol = function (index, col) {
        if (!_.isNumber(index)) {
            index = self.getTextLinesIndex();
        }
        if (!_.isNumber(col)) {
            col = self.cursorPos.col;
        }
        const lineText = self.getText(index);
        return self.getDisplayWidth(lineText.substring(0, col));
    };

    //
    //  ANSI seems to want tabs to default to 8 characters. See the following:
    //  * http://www.ansi-bbs.org/ansi-bbs2/control_chars/
    //  * http://www.bbsdocumentary.com/library/PROGRAMS/GRAPHICS/ANSI/bansi.txt
    //
    //  This seems overkill though, so let's default to 4 :)
    //  :TODO: what shoudl this really be? Maybe 8 is OK
    //
    this.tabWidth = _.isNumber(options.tabWidth) ? options.tabWidth : 4;

    this.textLines = [];
    this.topVisibleIndex = 0;
    this.mode = options.mode || 'edit'; //  edit | preview | read-only

    if ('preview' === this.mode) {
        this.autoScroll = options.autoScroll || true;
        this.tabSwitchesView = true;
    } else {
        this.autoScroll = options.autoScroll || false;
        this.tabSwitchesView = options.tabSwitchesView || false;
    }
    //
    //  cursorPos represents zero-based row, col positions
    //  within the editor itself
    //
    this.cursorPos = { col: 0, row: 0 };

    this.getSGRFor = function (sgrFor) {
        return (
            {
                text: self.getSGR(),
            }[sgrFor] || self.getSGR()
        );
    };

    this.isEditMode = function () {
        return 'edit' === self.mode;
    };

    this.isPreviewMode = function () {
        return 'preview' === self.mode;
    };

    //  :TODO: Most of the calls to this could be avoided via incrementRow(), decrementRow() that keeps track or such
    this.getTextLinesIndex = function (row) {
        if (!_.isNumber(row)) {
            row = self.cursorPos.row;
        }
        var index = self.topVisibleIndex + row;
        return index;
    };

    this.getRemainingLinesBelowRow = function (row) {
        if (!_.isNumber(row)) {
            row = self.cursorPos.row;
        }
        return self.textLines.length - (self.topVisibleIndex + row) - 1;
    };

    this.getNextEndOfLineIndex = function (startIndex) {
        for (var i = startIndex; i < self.textLines.length; i++) {
            if (self.textLines[i].eol) {
                return i;
            }
        }
        return self.textLines.length;
    };

    this.toggleTextCursor = function (action) {
        self.client.term.rawWrite(
            `${self.getSGRFor('text')}${
                'hide' === action ? ansi.hideCursor() : ansi.showCursor()
            }`
        );
    };

    this.redrawRows = function (startRow, endRow) {
        self.toggleTextCursor('hide');

        const startIndex = self.getTextLinesIndex(startRow);
        const endIndex = Math.min(self.getTextLinesIndex(endRow), self.textLines.length);
        const absPos = self.getAbsolutePosition(startRow, 0);

        for (let i = startIndex; i < endIndex; ++i) {

            const renderText = self.getRenderText(i);
            const displayWidth = self.getDisplayWidth(renderText);
            const trimmedText = displayWidth > self.dimens.width
                ? renderText.split('').reduce((acc, char) => {
                    const width = self.getDisplayWidth(char);
                    if (self.getDisplayWidth(acc) + width <= self.dimens.width) {
                        return acc + char;
                    }
                    return acc;
                }, '')
                : renderText;

            self.client.term.write(
                `${ansi.goto(absPos.row++, absPos.col)}${renderText}`,
                 false
            );
        }

        self.toggleTextCursor('show');

        return absPos.row - self.position.row; //  row we ended on
    };

    this.eraseRows = function (startRow, endRow) {
        self.toggleTextCursor('hide');

        const absPos = self.getAbsolutePosition(startRow, 0);
        const absPosEnd = self.getAbsolutePosition(endRow, 0);
        const eraseFiller = ' '.repeat(self.dimens.width); //new Array(self.dimens.width).join(' ');

        while (absPos.row < absPosEnd.row) {
            self.client.term.write(
                `${ansi.goto(absPos.row++, absPos.col)}${eraseFiller}`,
                false //  convertLineFeeds
            );
        }

        self.toggleTextCursor('show');
    };

    this.redrawVisibleArea = function () {
        assert(self.topVisibleIndex <= self.textLines.length);
        const lastRow = self.redrawRows(0, self.dimens.height);

        self.eraseRows(lastRow, self.dimens.height);
        /*

        //  :TOOD: create eraseRows(startRow, endRow)
        if(lastRow < self.dimens.height) {
            var absPos  = self.getAbsolutePosition(lastRow, 0);
            var empty   = new Array(self.dimens.width).join(' ');
            while(lastRow++ < self.dimens.height) {
                self.client.term.write(ansi.goto(absPos.row++, absPos.col));
                self.client.term.write(empty);
            }
        }
        */
    };

    this.getVisibleText = function (index) {
        if (!_.isNumber(index)) {
            index = self.getTextLinesIndex();
        }
        return self.textLines[index].text.replace(/\t/g, ' ');
    };

    this.getText = function (index) {
        if (!_.isNumber(index)) {
            index = self.getTextLinesIndex();
        }
        return self.textLines.length > index ? self.textLines[index].text : '';
    };

    this.getTextLength = function (index) {
        if (!_.isNumber(index)) {
            index = self.getTextLinesIndex();
        }
        return self.textLines.length > index ? self.textLines[index].text.length : 0;
    };

    this.getCharacter = function (index, col) {
        if (!_.isNumber(col)) {
            col = self.cursorPos.col;
        }
        return self.getText(index).charAt(col);
    };

    this.isTab = function (index, col) {
        return '\t' === self.getCharacter(index, col);
    };

    this.getTextEndOfLineColumn = function (index) {
        if (!_.isNumber(index)) {
            index = self.getTextLinesIndex();
        }
        return self.getTextLength(index);
    };

    this.getRenderText = function (index) {
        let text = self.getVisibleText(index);
            const displayWidth = self.getDisplayWidth(text);
            const remain = self.dimens.width - displayWidth;

        if (remain > 0) {
            text += ' '.repeat(remain); // + 1);
        }

        return text;
    };

    this.getTextLines = function (startIndex, endIndex) {
        var lines;
        if (startIndex === endIndex) {
            lines = [self.textLines[startIndex]];
        } else {
            lines = self.textLines.slice(startIndex, endIndex + 1); //  "slice extracts up to but not including end."
        }
        return lines;
    };

    this.getOutputText = function (startIndex, endIndex, eolMarker, options) {
        const lines = self.getTextLines(startIndex, endIndex);
        let text = '';
        const re = new RegExp('\\t{1,' + self.tabWidth + '}', 'g');

        lines.forEach(line => {
            text += line.text.replace(re, '\t');

            if (options.forceLineTerms || (eolMarker && line.eol)) {
                text += eolMarker;
            }
        });

        return text;
    };

    this.getContiguousText = function (startIndex, endIndex, includeEol) {
        var lines = self.getTextLines(startIndex, endIndex);
        var text = '';
        for (var i = 0; i < lines.length; ++i) {
            text += lines[i].text;
            if (includeEol && lines[i].eol) {
                text += '\n';
            }
        }
        return text;
    };

    this.replaceCharacterInText = function (c, index, col) {
        self.textLines[index].text = strUtil.replaceAt(
            self.textLines[index].text,
            col,
            c
        );
    };

    /*
    this.editTextAtPosition = function(editAction, text, index, col) {
        switch(editAction) {
            case 'insert' :
                self.insertCharactersInText(text, index, col);
                break;

            case 'deleteForward' :
                break;

            case 'deleteBack' :
                break;

            case 'replace' :
                break;
        }
    };
    */

    this.updateTextWordWrap = function (index) {
        const nextEolIndex = self.getNextEndOfLineIndex(index);
        const wrapped = self.wordWrapSingleLine(
            self.getContiguousText(index, nextEolIndex),
            'tabsIntact'
        );
        const newLines = wrapped.wrapped.map(l => {
            return { text: l };
        });

        newLines[newLines.length - 1].eol = true;

        Array.prototype.splice.apply(
            self.textLines,
            [index, nextEolIndex - index + 1].concat(newLines)
        );

        return wrapped.firstWrapRange;
    };

    this.removeCharactersFromText = function (index, col, operation, count) {
        if ('delete' === operation) {
            self.textLines[index].text =
                self.textLines[index].text.slice(0, col) +
                self.textLines[index].text.slice(col + count);

            self.updateTextWordWrap(index);
            self.redrawRows(self.cursorPos.row, self.dimens.height);
            self.moveClientCursorToCursorPos();
        } else if ('backspace' === operation) {
            //  :TODO: method for splicing text
            self.textLines[index].text =
                self.textLines[index].text.slice(0, col - (count - 1)) +
                self.textLines[index].text.slice(col + 1);

            self.cursorPos.col -= count - 1;

            self.updateTextWordWrap(index);
            self.redrawRows(self.cursorPos.row, self.dimens.height);

            self.moveClientCursorToCursorPos();
        } else if ('delete line' === operation) {
            //
            //  Delete a visible line. Note that this is *not* the "physical" line, or
            //  1:n entries up to eol! This is to keep consistency with home/end, and
            //  some other text editors such as nano. Sublime for example want to
            //  treat all of these things using the physical approach, but this seems
            //  a bit odd in this context.
            //
            var isLastLine = index === self.textLines.length - 1;
            var hadEol = self.textLines[index].eol;

            self.textLines.splice(index, 1);
            if (hadEol && self.textLines.length > index && !self.textLines[index].eol) {
                self.textLines[index].eol = true;
            }

            //
            //  Create a empty edit buffer if necessary
            //  :TODO: Make this a method
            if (self.textLines.length < 1) {
                self.textLines = [{ text: '', eol: true }];
                isLastLine = false; //  resetting
            }

            self.cursorPos.col = 0;

            var lastRow = self.redrawRows(self.cursorPos.row, self.dimens.height);
            self.eraseRows(lastRow, self.dimens.height);

            //
            //  If we just deleted the last line in the buffer, move up
            //
            if (isLastLine) {
                self.cursorEndOfPreviousLine();
            } else {
                self.moveClientCursorToCursorPos();
            }
        }
    };

    this.insertCharactersInText = function (c, index, col) {
        const prevTextLength = self.getTextLength(index);
        let editingEol = self.cursorPos.col === prevTextLength;

        self.textLines[index].text = [
            self.textLines[index].text.slice(0, col),
            c,
            self.textLines[index].text.slice(col),
        ].join('');

        const charWidth = self.getDisplayWidth(c);
        self.cursorPos.col += c.length;

        if (self.getDisplayWidth(self.getText(index)) > self.dimens.width) {
            //
            //  Update word wrapping and |cursorOffset| if the cursor
            //  was within the bounds of the wrapped text
            //
            let cursorOffset;
            const lastCol = self.cursorPos.col - c.length;
            const firstWrapRange = self.updateTextWordWrap(index);
            if (lastCol >= firstWrapRange.start && lastCol <= firstWrapRange.end) {
                cursorOffset = self.cursorPos.col - firstWrapRange.start;
                editingEol = true; //override
            } else {
                cursorOffset = firstWrapRange.end;
            }

            //  redraw from current row to end of visible area
            self.redrawRows(self.cursorPos.row, self.dimens.height);

            //  If we're editing mid, we're done here. Else, we need to
            //  move the cursor to the new editing position after a wrap
            if (editingEol) {
                self.cursorBeginOfNextLine();
                self.cursorPos.col += cursorOffset;
                self.client.term.rawWrite(ansi.right(self.getDisplayWidth(self.getText(index).substring(0, cursorOffset))));
            } else {
                self.moveClientCursorToCursorPos();
            }
        } else {
            //
            //  We must only redraw from col -> end of current visible line
            //
            const absPosBefore = self.getAbsolutePosition(self.cursorPos.row, self.getCursorDisplayCol(index, col));
            const textAfterInsert = self.getText(index).slice(col);
            const displayText = textAfterInsert.substring(0, self.dimens.width - self.getCursorDisplayCol(index, col));
            self.client.term.rawWrite(
                `${ansi.goto(absPosBefore.row, absPosBefore.col)}${displayText}`
            );
            self.moveClientCursorToCursorPos();
        }
    };

    this.getRemainingTabWidth = function (col) {
        if (!_.isNumber(col)) {
            col = self.cursorPos.col;
        }
        return self.tabWidth - (col % self.tabWidth);
    };

    this.calculateTabStops = function () {
        self.tabStops = [0];
        var col = 0;
        while (col < self.dimens.width) {
            col += self.getRemainingTabWidth(col);
            self.tabStops.push(col);
        }
    };

    this.getNextTabStop = function (col) {
        var i = self.tabStops.length;
        while (self.tabStops[--i] > col);
        return self.tabStops[++i];
    };

    this.getPrevTabStop = function (col) {
        var i = self.tabStops.length;
        while (self.tabStops[--i] >= col);
        return self.tabStops[i];
    };

    this.expandTab = function (col, expandChar) {
        expandChar = expandChar || ' ';
        return new Array(self.getRemainingTabWidth(col)).join(expandChar);
    };

    this.wordWrapSingleLine = function (line, tabHandling = 'expand') {
        return wordWrapText(line, {
            width: self.dimens.width,
            tabHandling: tabHandling,
            tabWidth: self.tabWidth,
            tabChar: '\t',
        });
    };

    this.setTextLines = function (lines, index, termWithEol) {
        if (
            0 === index &&
            (0 === self.textLines.length ||
                (self.textLines.length === 1 && '' === self.textLines[0].text))
        ) {
            //  quick path: just set the things
            self.textLines = lines
                .slice(0, -1)
                .map(l => {
                    return { text: l };
                })
                .concat({ text: lines[lines.length - 1], eol: termWithEol });
        } else {
            //  insert somewhere in textLines...
            if (index > self.textLines.length) {
                //  fill with empty
                self.textLines.splice(
                    self.textLines.length,
                    0,
                    ...Array.from({ length: index - self.textLines.length }).map(() => {
                        return { text: '' };
                    })
                );
            }

            const newLines = lines
                .slice(0, -1)
                .map(l => {
                    return { text: l };
                })
                .concat({ text: lines[lines.length - 1], eol: termWithEol });

            self.textLines.splice(index, 0, ...newLines);
        }
    };

    this.setAnsiWithOptions = function (ansi, options, cb) {
        function setLines(text) {
            text = strUtil.splitTextAtTerms(text);

            let index = 0;

            text.forEach(line => {
                self.setTextLines([line], index, true); //  true=termWithEol
                index += 1;
            });

            self.cursorStartOfDocument();

            if (cb) {
                return cb(null);
            }
        }

        if (options.prepped) {
            return setLines(ansi);
        }

        ansiPrep(
            ansi,
            {
                termWidth: options.termWidth || this.client.term.termWidth,
                termHeight: options.termHeight || this.client.term.termHeight,
                cols: this.dimens.width,
                rows: 'auto',
                startCol: this.position.col,
                forceLineTerm: options.forceLineTerm,
            },
            (err, preppedAnsi) => {
                return setLines(err ? ansi : preppedAnsi);
            }
        );
    };

    this.insertRawText = function (text, index, col) {
        //
        //  Perform the following on |text|:
        //  *   Normalize various line feed formats -> \n
        //  *   Remove some control characters (e.g. \b)
        //  *   Word wrap lines such that they fit in the visible workspace.
        //      Each actual line will then take 1:n elements in textLines[].
        //  *   Each tab will be appropriately expanded and take 1:n \t
        //      characters. This allows us to know when we're in tab space
        //      when doing cursor movement/etc.
        //
        //
        //  Try to handle any possible newline that can be fed to us.
        //  See http://stackoverflow.com/questions/5034781/js-regex-to-split-by-line
        //
        //  :TODO: support index/col insertion point

        if (_.isNumber(index)) {
            if (_.isNumber(col)) {
                //
                //  Modify text to have information from index
                //  before and and after column
                //
                //  :TODO: Need to clean this string (e.g. collapse tabs)
                text = self.textLines;

                //  :TODO: Remove original line @ index
            }
        } else {
            index = self.textLines.length;
        }

        text = strUtil.splitTextAtTerms(text);

        let wrapped;
        text.forEach(line => {
            wrapped = self.wordWrapSingleLine(line, 'expand').wrapped;

            self.setTextLines(wrapped, index, true); //  true=termWithEol
            index += wrapped.length;
        });
    };

    this.getAbsolutePosition = function (row, col) {
        return {
            row: self.position.row + row,
            col: self.position.col + col,
        };
    };

    this.moveClientCursorToCursorPos = function () {
        const displayCol = self.getCursorDisplayCol();
        var absPos = self.getAbsolutePosition(self.cursorPos.row, displayCol);

        self.client.term.rawWrite(`${ansi.goto(absPos.row, absPos.col)}${ansi.showCursor()}`);
    };

    this.keyPressCharacter = function (c) {
        var index = self.getTextLinesIndex();

        //
        //  :TODO: stuff that needs to happen
        //  * Break up into smaller methods
        //  * Even in overtype mode, word wrapping must apply if past bounds
        //  * A lot of this can be used for backspacing also
        //  * See how Sublime treats tabs in *non* overtype mode... just overwrite them?
        //
        //

        if (self.overtypeMode) {
            //  :TODO: special handing for insert over eol mark?
            self.replaceCharacterInText(c, index, self.cursorPos.col);
            self.cursorPos.col++;
            self.client.term.write(c);
                self.moveClientCursorToCursorPos();
        } else {
            self.insertCharactersInText(c, index, self.cursorPos.col);
        }

        self.emitEditPosition();
    };

    this.keyPressUp = function () {
        if (self.cursorPos.row > 0) {
            self.cursorPos.row--;
            self.client.term.rawWrite(ansi.up());

            const displayWidth = self.getCursorDisplayCol();
            self.adjustCursorIfPastEndOfLine(true);
            self.moveClientCursorToCursorPos();
        } else {
            self.scrollDocumentDown();
            self.adjustCursorIfPastEndOfLine(true);
        }

        self.emitEditPosition();
    };

    this.keyPressDown = function () {
        var lastVisibleRow =
            Math.min(self.dimens.height, self.textLines.length - self.topVisibleIndex) -
            1;

        if (self.cursorPos.row < lastVisibleRow) {
            self.cursorPos.row++;
            self.client.term.rawWrite(ansi.down());

            if (!self.adjustCursorToNextTab('down')) {
                self.adjustCursorIfPastEndOfLine(false);
            }
        } else {
            self.scrollDocumentUp();
            self.adjustCursorIfPastEndOfLine(true);
        }

        self.emitEditPosition();
    };

    this.keyPressLeft = function () {
        if (self.cursorPos.col > 0) {
           const index = self.getTextLinesIndex();
           const currentText = self.getText(index);
           const prevChar = currentText.charAt(self.cursorPos.col - 1);
           const prevCharWidth = self.getDisplayWidth(prevChar);

            self.cursorPos.col--;
            self.client.term.rawWrite(ansi.left(prevCharWidth));
            self.adjustCursorIfPastEndOfLine(false);
        } else {
            self.cursorEndOfPreviousLine();
        }

        self.emitEditPosition();
    };

    this.keyPressRight = function () {
        var eolColumn = self.getTextEndOfLineColumn();
        if (self.cursorPos.col < eolColumn) {
            const prevDisplayWidth = self.getCursorDisplayCol();
            self.cursorPos.col++;

            const displayWidth = self.getCursorDisplayCol();
            self.client.term.rawWrite(ansi.right(displayWidth - prevDisplayWidth));
        } else {
            self.cursorBeginOfNextLine();
        }

        self.emitEditPosition();
    };

    this.keyPressHome = function () {
        var firstNonWhitespace = self.getVisibleText().search(/\S/);
        if (-1 !== firstNonWhitespace) {
            self.cursorPos.col = firstNonWhitespace;
        } else {
            self.cursorPos.col = 0;
        }
        self.moveClientCursorToCursorPos();

        self.emitEditPosition();
    };

    this.keyPressEnd = function () {
        self.cursorPos.col = self.getTextEndOfLineColumn();
        self.moveClientCursorToCursorPos();
        self.emitEditPosition();
    };

    this.keyPressPageUp = function () {
        if (self.topVisibleIndex > 0) {
            self.topVisibleIndex = Math.max(0, self.topVisibleIndex - self.dimens.height);
            self.redraw();
            self.adjustCursorIfPastEndOfLine(true);
        } else {
            self.cursorPos.row = 0;
            self.moveClientCursorToCursorPos(); //  :TODO: ajust if eol, etc.
        }

        self.emitEditPosition();
    };

    this.keyPressPageDown = function () {
        var linesBelow = self.getRemainingLinesBelowRow();
        if (linesBelow > 0) {
            self.topVisibleIndex += Math.min(linesBelow, self.dimens.height);
            self.redraw();
            self.adjustCursorIfPastEndOfLine(true);
        }

        self.emitEditPosition();
    };

    this.keyPressLineFeed = function () {
        //
        //  Break up text from cursor position, redraw, and update cursor
        //  position to start of next line
        //
        var index = self.getTextLinesIndex();
        var nextEolIndex = self.getNextEndOfLineIndex(index);
        var text = self.getContiguousText(index, nextEolIndex);
        const newLines = self.wordWrapSingleLine(
            text.slice(self.cursorPos.col),
            'tabsIntact'
        ).wrapped;

        newLines.unshift({ text: text.slice(0, self.cursorPos.col), eol: true });
        for (var i = 1; i < newLines.length; ++i) {
            newLines[i] = { text: newLines[i] };
        }
        newLines[newLines.length - 1].eol = true;

        Array.prototype.splice.apply(
            self.textLines,
            [index, nextEolIndex - index + 1].concat(newLines)
        );

        //  redraw from current row to end of visible area
        self.redrawRows(self.cursorPos.row, self.dimens.height);
        self.cursorBeginOfNextLine();

        self.emitEditPosition();
    };

    this.keyPressInsert = function () {
        self.toggleTextEditMode();
    };

    this.keyPressTab = function () {
        var index = self.getTextLinesIndex();
        self.insertCharactersInText(
            self.expandTab(self.cursorPos.col, '\t') + '\t',
            index,
            self.cursorPos.col
        );

        self.emitEditPosition();
    };

    this.keyPressBackspace = function () {
        var index = self.getTextLinesIndex();

        if (self.cursorPos.col >= 1) {
            //
            //  Don't want to delete character at cursor, but rather the character
            //  to the left of the cursor!
            //
            self.cursorPos.col -= 1;

            self.removeCharactersFromText(index, self.cursorPos.col, 'backspace', 1);
        } else if (self.cursorPos.row > 0) {
            const prevIndex = self.getTextLinesIndex(self.cursorPos.row - 1);
            const currentText = self.getText(index);
            const prevText = self.getText(prevIndex);

            self.textLines[prevIndex].text = prevText + currentText;
            self.textLines[prevIndex].eol = self.textLines[index].eol;
            self.textLines.splice(index, 1);

            self.cursorPos.row--;
            self.cursorPos.col = prevText.length;
        
            self.redrawRows(self.cursorPos.row, self.dimens.height);
            self.moveClientCursorToCursorPos();

        } else {
            self.keyPressLeft();
        }

        self.emitEditPosition();
    };

    this.keyPressDelete = function () {
        const lineIndex = self.getTextLinesIndex();

        if (
            0 === self.cursorPos.col &&
            0 === self.textLines[lineIndex].text.length &&
            self.textLines.length > 0
        ) {
            //
            //  Start of line and nothing left. Just delete the line
            //
            self.removeCharactersFromText(lineIndex, 0, 'delete line');
        } else if (
            self.cursorPos.col === self.getTextEndOfLineColumn(lineIndex) &&
            lineIndex < self.textLines.length - 1
        ) {
            const nextIndex = lineIndex + 1;
            const currentText = self.getText(lineIndex);
            const nextText = self.getText(nextIndex);

            self.textLines[lineIndex].text = currentText + nextText;
            self.textLines[lineIndex].eol = self.textLines[nextIndex].eol;
            self.textLines.splice(nextIndex, 1);

            self.redrawRows(self.cursorPos.row, self.dimens.height);
            self.moveClientCursorToCursorPos();

        } else {
            self.removeCharactersFromText(lineIndex, self.cursorPos.col, 'delete', 1);
        }

        self.emitEditPosition();
    };

    this.keyPressDeleteLine = function () {
        if (self.textLines.length > 0) {
            self.removeCharactersFromText(self.getTextLinesIndex(), 0, 'delete line');
        }

        self.emitEditPosition();
    };

    this.adjustCursorIfPastEndOfLine = function (forceUpdate) {
        var eolColumn = self.getTextEndOfLineColumn();
        if (self.cursorPos.col > eolColumn) {
            self.cursorPos.col = eolColumn;
            forceUpdate = true;
        }

        if (forceUpdate) {
            self.moveClientCursorToCursorPos();
        }
    };

    this.adjustCursorToNextTab = function (direction) {
        if (self.isTab()) {
            var move;
            switch (direction) {
                //
                //  Next tabstop to the right
                //
                case 'right':
                    move = self.getNextTabStop(self.cursorPos.col) - self.cursorPos.col;
                    self.cursorPos.col += move;
                    self.client.term.rawWrite(ansi.right(move));
                    break;

                //
                //  Next tabstop to the left
                //
                case 'left':
                    move = self.cursorPos.col - self.getPrevTabStop(self.cursorPos.col);
                    self.cursorPos.col -= move;
                    self.client.term.rawWrite(ansi.left(move));
                    break;

                case 'up':
                case 'down':
                    //
                    //  Jump to the tabstop nearest the cursor
                    //
                    var newCol = self.tabStops.reduce(function r(prev, curr) {
                        return Math.abs(curr - self.cursorPos.col) <
                            Math.abs(prev - self.cursorPos.col)
                            ? curr
                            : prev;
                    });

                    if (newCol > self.cursorPos.col) {
                        move = newCol - self.cursorPos.col;
                        self.cursorPos.col += move;
                        self.client.term.rawWrite(ansi.right(move));
                    } else if (newCol < self.cursorPos.col) {
                        move = self.cursorPos.col - newCol;
                        self.cursorPos.col -= move;
                        self.client.term.rawWrite(ansi.left(move));
                    }
                    break;
            }

            return true;
        }
        return false; //  did not fall on a tab
    };

    this.cursorStartOfDocument = function () {
        self.topVisibleIndex = 0;
        self.cursorPos = { row: 0, col: 0 };

        self.redraw();
        self.moveClientCursorToCursorPos();
    };

    this.cursorEndOfDocument = function () {
        self.topVisibleIndex = Math.max(self.textLines.length - self.dimens.height, 0);
        self.cursorPos.row = self.textLines.length - self.topVisibleIndex - 1;
        self.cursorPos.col = self.getTextEndOfLineColumn();

        self.redraw();
        self.moveClientCursorToCursorPos();
    };

    this.cursorBeginOfNextLine = function () {
        //  e.g. when scrolling right past eol
        var linesBelow = self.getRemainingLinesBelowRow();

        if (linesBelow > 0) {
            var lastVisibleRow = Math.min(self.dimens.height, self.textLines.length) - 1;
            if (self.cursorPos.row < lastVisibleRow) {
                self.cursorPos.row++;
            } else {
                self.scrollDocumentUp();
            }
            self.keyPressHome(); //  same as pressing 'home'
        }
    };

    this.cursorEndOfPreviousLine = function () {
        //  e.g. when scrolling left past start of line
        var moveToEnd;
        if (self.cursorPos.row > 0) {
            self.cursorPos.row--;
            moveToEnd = true;
        } else if (self.topVisibleIndex > 0) {
            self.scrollDocumentDown();
            moveToEnd = true;
        }

        if (moveToEnd) {
            self.keyPressEnd(); //  same as pressing 'end'
        }
    };

    /*
    this.cusorEndOfNextLine = function() {
        var linesBelow = self.getRemainingLinesBelowRow();

        if(linesBelow > 0) {
            var lastVisibleRow = Math.min(self.dimens.height, self.textLines.length) - 1;
            if(self.cursorPos.row < lastVisibleRow) {
                self.cursorPos.row++;
            } else {
                self.scrollDocumentUp();
            }
            self.keyPressEnd(); //  same as pressing 'end'
        }
    };
    */

    this.scrollDocumentUp = function () {
        //
        //  Note: We scroll *up* when the cursor goes *down* beyond
        //  the visible area!
        //
        var linesBelow = self.getRemainingLinesBelowRow();
        if (linesBelow > 0) {
            self.topVisibleIndex++;
            self.redraw();
        }
    };

    this.scrollDocumentDown = function () {
        //
        //  Note: We scroll *down* when the cursor goes *up* beyond
        //  the visible area!
        //
        if (self.topVisibleIndex > 0) {
            self.topVisibleIndex--;
            self.redraw();
        }
    };

    this.emitEditPosition = function () {
        self.emit('edit position', self.getEditPosition());
    };

    this.toggleTextEditMode = function () {
        self.overtypeMode = !self.overtypeMode;
        self.emit('text edit mode', self.getTextEditMode());
    };

    this.insertRawText(''); //  init to blank/empty
}

require('util').inherits(MultiLineEditTextView, View);

MultiLineEditTextView.prototype.setWidth = function (width) {
    MultiLineEditTextView.super_.prototype.setWidth.call(this, width);

    this.calculateTabStops();
};

MultiLineEditTextView.prototype.redraw = function () {
    MultiLineEditTextView.super_.prototype.redraw.call(this);

    this.redrawVisibleArea();
};

MultiLineEditTextView.prototype.setFocus = function (focused) {
    this.client.term.rawWrite(this.getSGRFor('text'));
    this.moveClientCursorToCursorPos();

    MultiLineEditTextView.super_.prototype.setFocus.call(this, focused);
};

MultiLineEditTextView.prototype.setText = function (
    text,
    options = { scrollMode: 'default' }
) {
    this.textLines = [];
    this.addText(text, options);
    /*this.insertRawText(text);

    if(this.isEditMode()) {
        this.cursorEndOfDocument();
    } else if(this.isPreviewMode()) {
        this.cursorStartOfDocument();
    }*/
};

MultiLineEditTextView.prototype.setAnsi = function (
    ansi,
    options = { prepped: false },
    cb
) {
    this.textLines = [];
    return this.setAnsiWithOptions(ansi, options, cb);
};

MultiLineEditTextView.prototype.addText = function (
    text,
    options = { scrollMode: 'default' }
) {
    this.insertRawText(text);

    switch (options.scrollMode) {
        case 'default':
            if (this.isEditMode() || this.autoScroll) {
                this.cursorEndOfDocument();
            } else {
                this.cursorStartOfDocument();
            }
            break;

        case 'top':
        case 'start':
            this.cursorStartOfDocument();
            break;

        case 'end':
        case 'bottom':
            this.cursorEndOfDocument();
            break;
    }
};

MultiLineEditTextView.prototype.getData = function (options = { forceLineTerms: false }) {
    return this.getOutputText(0, this.textLines.length, '\r\n', options);
};

MultiLineEditTextView.prototype.setPropertyValue = function (propName, value) {
    switch (propName) {
        case 'mode':
            this.mode = value;
            if ('preview' === value && !this.specialKeyMap.next) {
                this.specialKeyMap.next = ['tab'];
            }
            break;

        case 'autoScroll':
            this.autoScroll = value;
            break;

        case 'tabSwitchesView':
            this.tabSwitchesView = value;
            this.specialKeyMap.next = this.specialKeyMap.next || [];
            this.specialKeyMap.next.push('tab');
            break;
    }

    MultiLineEditTextView.super_.prototype.setPropertyValue.call(this, propName, value);
};

const HANDLED_SPECIAL_KEYS = [
    'up',
    'down',
    'left',
    'right',
    'home',
    'end',
    'page up',
    'page down',
    'line feed',
    'insert',
    'tab',
    'backspace',
    'delete',
    'delete line',
];

const PREVIEW_MODE_KEYS = ['up', 'down', 'page up', 'page down'];

MultiLineEditTextView.prototype.onKeyPress = function (ch, key) {
    const self = this;
    let handled;

    if (key) {
        HANDLED_SPECIAL_KEYS.forEach(function aKey(specialKey) {
            if (self.isKeyMapped(specialKey, key.name)) {
                if (
                    self.isPreviewMode() &&
                    -1 === PREVIEW_MODE_KEYS.indexOf(specialKey)
                ) {
                    return;
                }

                if ('tab' !== key.name || !self.tabSwitchesView) {
                    self[_.camelCase('keyPress ' + specialKey)]();
                    handled = true;
                }
            }
        });
    }

    if (self.isEditMode() && ch && strUtil.isPrintable(ch)) {
        this.keyPressCharacter(ch);
    }

    if (!handled) {
        MultiLineEditTextView.super_.prototype.onKeyPress.call(this, ch, key);
    }
};

MultiLineEditTextView.prototype.scrollUp = function () {
    this.scrollDocumentUp();
};

MultiLineEditTextView.prototype.scrollDown = function () {
    this.scrollDocumentDown();
};

MultiLineEditTextView.prototype.deleteLine = function (line) {
    this.textLines.splice(line, 1);
};

MultiLineEditTextView.prototype.getLineCount = function () {
    return this.textLines.length;
};

MultiLineEditTextView.prototype.getTextEditMode = function () {
    return this.overtypeMode ? 'overtype' : 'insert';
};

MultiLineEditTextView.prototype.getEditPosition = function () {
    var currentIndex = this.getTextLinesIndex() + 1;

    return {
        row: this.getTextLinesIndex(this.cursorPos.row),
        col: this.cursorPos.col,
        displayCol: this.getCursorDisplayCol(),
        percent: Math.floor((currentIndex / this.textLines.length) * 100),
        below: this.getRemainingLinesBelowRow(),
    };
};