www.pudn.com > BBS.rar > wordWindow.js

//////////////////////////////////////////////////// 
// 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( '
' ); 
		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( '
' ); 
			// 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( '
' ); 
 
		} 
		d.writeln( '
' ); 
	} 
	//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 = '
'; 
				break; 
			case "<": 
				htmlstr = '<'; 
				break; 
			case ">": 
				htmlstr = '>'; 
				break; 
		} 
		return htmlstr; 
	} else { 
		htmlstr = htmlstr.replace( //g, '>' ); 
		htmlstr = htmlstr.replace( /\n/g, '
' ); 
		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 = ''; 
	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; 
	} 
}