Subversion Repositories Applications.papyrus

////////////////////////////////////////////////////

// wordWindow object

////////////////////////////////////////////////////

function wordWindow() {

	// private properties

	this._forms = [];

	// private methods

	this._getWordObject = _getWordObject;

	//this._getSpellerObject = _getSpellerObject;

	this._wordInputStr = _wordInputStr;

	this._adjustIndexes = _adjustIndexes;

	this._isWordChar = _isWordChar;

	this._lastPos = _lastPos;

	// public properties

	this.wordChar = /[a-zA-Z]/;

	this.windowType = "wordWindow";

	this.originalSpellings = new Array();

	this.suggestions = new Array();

	this.checkWordBgColor = "pink";

	this.normWordBgColor = "white";

	this.text = "";

	this.textInputs = new Array();

	this.indexes = new Array();

	//this.speller = this._getSpellerObject();

	// public methods

	this.resetForm = resetForm;

	this.totalMisspellings = totalMisspellings;

	this.totalWords = totalWords;

	this.totalPreviousWords = totalPreviousWords;

	//this.getTextObjectArray = getTextObjectArray;

	this.getTextVal = getTextVal;

	this.setFocus = setFocus;

	this.removeFocus = removeFocus;

	this.setText = setText;

	//this.getTotalWords = getTotalWords;

	this.writeBody = writeBody;

	this.printForHtml = printForHtml;

}

function resetForm() {

	if( this._forms ) {

		for( var i = 0; i < this._forms.length; i++ ) {

			this._forms[i].reset();

		}

	}

	return true;

}

function totalMisspellings() {

	var total_words = 0;

	for( var i = 0; i < this.textInputs.length; i++ ) {

		total_words += this.totalWords( i );

	}

	return total_words;

}

function totalWords( textIndex ) {

	return this.originalSpellings[textIndex].length;

}

function totalPreviousWords( textIndex, wordIndex ) {

	var total_words = 0;

	for( var i = 0; i <= textIndex; i++ ) {

		for( var j = 0; j < this.totalWords( i ); j++ ) {

			if( i == textIndex && j == wordIndex ) {

				break;

			} else {

				total_words++;

			}

		}

	}

	return total_words;

}

//function getTextObjectArray() {

//	return this._form.elements;

//}

function getTextVal( textIndex, wordIndex ) {

	var word = this._getWordObject( textIndex, wordIndex );

	if( word ) {

		return word.value;

	}

}

function setFocus( textIndex, wordIndex ) {

	var word = this._getWordObject( textIndex, wordIndex );

	if( word ) {

		if( word.type == "text" ) {

			word.focus();

			word.style.backgroundColor = this.checkWordBgColor;

		}

	}

}

function removeFocus( textIndex, wordIndex ) {

	var word = this._getWordObject( textIndex, wordIndex );

	if( word ) {

		if( word.type == "text" ) {

			word.blur();

			word.style.backgroundColor = this.normWordBgColor;

		}

	}

}

function setText( textIndex, wordIndex, newText ) {

	var word = this._getWordObject( textIndex, wordIndex );

	var beginStr;

	var endStr;

	if( word ) {

		var pos = this.indexes[textIndex][wordIndex];

		var oldText = word.value;

		// update the text given the index of the string

		beginStr = this.textInputs[textIndex].substring( 0, pos );

		endStr = this.textInputs[textIndex].substring(

			pos + oldText.length,

			this.textInputs[textIndex].length

		);

		this.textInputs[textIndex] = beginStr + newText + endStr;

		// adjust the indexes on the stack given the differences in

		// length between the new word and old word.

		var lengthDiff = newText.length - oldText.length;

		this._adjustIndexes( textIndex, wordIndex, lengthDiff );

		word.size = newText.length;

		word.value = newText;

		this.removeFocus( textIndex, wordIndex );

	}

}

function writeBody() {

	var d = window.document;

	var is_html = false;

	d.open();

	// iterate through each text input.

	for( var txtid = 0; txtid < this.textInputs.length; txtid++ ) {

		var end_idx = 0;

		var begin_idx = 0;

		d.writeln( '<form name="textInput'+txtid+'">' );

		var wordtxt = this.textInputs[txtid];

		this.indexes[txtid] = [];

		if( wordtxt ) {

			var orig = this.originalSpellings[txtid];

			if( !orig ) break;

			//!!! plain text, or HTML mode?

			d.writeln( '<div class="plainText">' );

			// iterate through each occurrence of a misspelled word.

			for( var i = 0; i < orig.length; i++ ) {

				// find the position of the current misspelled word,

				// starting at the last misspelled word.

				// and keep looking if it's a substring of another word

				do {

					begin_idx = wordtxt.indexOf( orig[i], end_idx );

					end_idx = begin_idx + orig[i].length;

					// word not found? messed up!

					if( begin_idx == -1 ) break;

					// look at the characters immediately before and after

					// the word. If they are word characters we'll keep looking.

					var before_char = wordtxt.charAt( begin_idx - 1 );

					var after_char = wordtxt.charAt( end_idx );

				} while (

					this._isWordChar( before_char )

					|| this._isWordChar( after_char )

				);

				// keep track of its position in the original text.

				this.indexes[txtid][i] = begin_idx;

				// write out the characters before the current misspelled word

				for( var j = this._lastPos( txtid, i ); j < begin_idx; j++ ) {

					// !!! html mode? make it html compatible

					d.write( this.printForHtml( wordtxt.charAt( j )));

				}

				// write out the misspelled word.

				d.write( this._wordInputStr( orig[i] ));

				// if it's the last word, write out the rest of the text

				if( i == orig.length-1 ){

					d.write( printForHtml( wordtxt.substr( end_idx )));

				}

			}

			d.writeln( '</div>' );

		}

		d.writeln( '</form>' );

	}

	//for ( var j = 0; j < d.forms.length; j++ ) {

	//	alert( d.forms[j].name );

	//	for( var k = 0; k < d.forms[j].elements.length; k++ ) {

	//		alert( d.forms[j].elements[k].name + ": " + d.forms[j].elements[k].value );

	//	}

	//}

	// set the _forms property

	this._forms = d.forms;

	d.close();

}

// return the character index in the full text after the last word we evaluated

function _lastPos( txtid, idx ) {

	if( idx > 0 )

		return this.indexes[txtid][idx-1] + this.originalSpellings[txtid][idx-1].length;

	else

		return 0;

}

function printForHtml( n ) {

	return n ;		// by FredCK

/*

	var htmlstr = n;

	if( htmlstr.length == 1 ) {

		// do simple case statement if it's just one character

		switch ( n ) {

			case "\n":

				htmlstr = '<br/>';

				break;

			case "<":

				htmlstr = '<';

				break;

			case ">":

				htmlstr = '>';

				break;

		}

		return htmlstr;

	} else {

		htmlstr = htmlstr.replace( /</g, '&lt' );

		htmlstr = htmlstr.replace( />/g, '&gt' );

		htmlstr = htmlstr.replace( /\n/g, '<br/>' );

		return htmlstr;

	}

*/

}

function _isWordChar( letter ) {

	if( letter.search( this.wordChar ) == -1 ) {

		return false;

	} else {

		return true;

	}

}

function _getWordObject( textIndex, wordIndex ) {

	if( this._forms[textIndex] ) {

		if( this._forms[textIndex].elements[wordIndex] ) {

			return this._forms[textIndex].elements[wordIndex];

		}

	}

	return null;

}

function _wordInputStr( word ) {

	var str = '<input readonly ';

	str += 'class="blend" type="text" value="' + word + '" size="' + word.length + '">';

	return str;

}

function _adjustIndexes( textIndex, wordIndex, lengthDiff ) {

	for( var i = wordIndex + 1; i < this.originalSpellings[textIndex].length; i++ ) {

		this.indexes[textIndex][i] = this.indexes[textIndex][i] + lengthDiff;

	}

}