enigma-bbs/core/mask_edit_text_view.js

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

var TextView		= require('./text_view.js').TextView;
var miscUtil		= require('./misc_util.js');
var strUtil			= require('./string_util.js');
var ansi			= require('./ansi_term.js');

//var util			= require('util');
var assert			= require('assert');
var _				= require('lodash');

exports.MaskEditTextView	= MaskEditTextView;

//	##/##/#### <--styleSGR2 if fillChar
//	  ^- styleSGR1
//	buildPattern -> [ RE, RE, '/', RE, RE, '/', RE, RE, RE, RE ]
//	patternIndex -----^

//	styleSGR1: Literal's (non-focus)
//	styleSGR2: Literals (focused)
//	styleSGR3: fillChar

//
//	:TODO:
//	* Hint, e.g. YYYY/MM/DD
//	* Return values with literals in place
//	

function MaskEditTextView(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;

	TextView.call(this, options);

	this.cursorPos			= { x : 0 };
	this.patternArrayPos	= 0;

	var self = this;

	this.maskPattern = options.maskPattern || '';

	this.clientBackspace = function() {
		var fillCharSGR = this.getStyleSGR(3) || this.getSGR();
		this.client.term.write('\b' + fillCharSGR + this.fillChar + '\b' + this.getFocusSGR());
	};

	this.drawText = function(s) {
		var textToDraw = strUtil.stylizeString(s, this.hasFocus ? this.focusTextStyle : this.textStyle);
		
		assert(textToDraw.length <= self.patternArray.length);

		//	draw out the text we have so far
		var i = 0;
		var t = 0;
		while(i < self.patternArray.length) {
			if(_.isRegExp(self.patternArray[i])) {
				if(t < textToDraw.length) {
					self.client.term.write((self.hasFocus ? self.getFocusSGR() : self.getSGR()) + textToDraw[t]);
					t++;
				} else {
					self.client.term.write((self.getStyleSGR(3) || '') + self.fillChar);
				}
			} else {
				var styleSgr = this.hasFocus ? (self.getStyleSGR(2) || '') : (self.getStyleSGR(1) || '');
				self.client.term.write(styleSgr + self.maskPattern[i]);
			}
			i++;
		}
	};

	this.buildPattern = function() {
		self.patternArray	= [];
		self.maxLength		= 0;

		for(var i = 0; i < self.maskPattern.length; i++) {
			//	:TODO: support escaped characters, e.g. \#. Also allow \\ for a '\' mark!
			if(self.maskPattern[i] in MaskEditTextView.maskPatternCharacterRegEx) {
				self.patternArray.push(MaskEditTextView.maskPatternCharacterRegEx[self.maskPattern[i]]);
				++self.maxLength;
			} else {
				self.patternArray.push(self.maskPattern[i]);
			}
		}
	};

	this.getEndOfTextColumn = function() {
		return this.position.col + this.patternArrayPos;
	};

	this.buildPattern();

}

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

MaskEditTextView.maskPatternCharacterRegEx = {
	'#'				: /[0-9]/,				//	Numeric
	'A'				: /[a-zA-Z]/,			//	Alpha
	'@'				: /[0-9a-zA-Z]/,		//	Alphanumeric
	'&'				: /[\w\d\s]/,			//	Any "printable" 32-126, 128-255
};

MaskEditTextView.prototype.setText = function(text) {
	MaskEditTextView.super_.prototype.setText.call(this, text);
	
	if(this.patternArray) {	//	:TODO: This is a hack - see TextView ctor note about setText()
		this.patternArrayPos = this.patternArray.length;
	}
};

MaskEditTextView.prototype.setMaskPattern = function(pattern) {
	this.dimens.width = pattern.length;

	this.maskPattern = pattern;
	this.buildPattern();
};

MaskEditTextView.prototype.onKeyPress = function(ch, key) {
	if(key) {
		if(this.isKeyMapped('backspace', key.name)) {
			if(this.text.length > 0) {
				this.patternArrayPos--;
				assert(this.patternArrayPos >= 0);

				if(_.isRegExp(this.patternArray[this.patternArrayPos])) {
					this.text = this.text.substr(0, this.text.length - 1);
					this.clientBackspace();
				} else {
					while(this.patternArrayPos > 0) {
						if(_.isRegExp(this.patternArray[this.patternArrayPos])) {			
							this.text = this.text.substr(0, this.text.length - 1);
							this.client.term.write(ansi.goto(this.position.row, this.getEndOfTextColumn() + 1));
							this.clientBackspace();
							break;
						}
						this.patternArrayPos--;
					}				
				}
			}

			return;
		} else if(this.isKeyMapped('clearLine', key.name)) {
			this.text				= '';
			this.patternArrayPos	= 0;
			this.setFocus(true);	//	redraw + adjust cursor

			return;
		}
	}

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

			if(!ch.match(this.patternArray[this.patternArrayPos])) {
				return;
			}

			this.text += ch;
			this.patternArrayPos++;

			while(this.patternArrayPos < this.patternArray.length && 
				!_.isRegExp(this.patternArray[this.patternArrayPos]))
			{
				this.patternArrayPos++;
			}

			this.redraw();
			this.client.term.write(ansi.goto(this.position.row, this.getEndOfTextColumn()));
		}
	}

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

MaskEditTextView.prototype.setPropertyValue = function(propName, value) {
	switch(propName) {
		case 'maskPattern'	: this.setMaskPattern(value); break;
	}

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

MaskEditTextView.prototype.getData = function() {
	var rawData = MaskEditTextView.super_.prototype.getData.call(this);
	
	if(!rawData || 0 === rawData.length) {
		return rawData;
	}
	
	var data	= '';

	assert(rawData.length <= this.patternArray.length);

	var p = 0;
	for(var i = 0; i < this.patternArray.length; ++i) {
		if(_.isRegExp(this.patternArray[i])) {
			data += rawData[p++];
		} else {
			data += this.patternArray[i];
		}
	}

	return data;
};