dojox-rails 0.13.0 → 0.14.0

data/vendor/assets/javascripts/dojox/av/README

@@ -1,65 +0,0 @@
--------------------------------------------------------------------------------
-DojoX Audio/Video
--------------------------------------------------------------------------------
-Version 0.1
-Release date: 01/15/2008
--------------------------------------------------------------------------------
-Project state:
-experimental
--------------------------------------------------------------------------------
-Credits
-	Tom Trenka (ttrenka AT gmail.com)
-    Mike Wilcox (AnM8tR AT Yahoo.com)
--------------------------------------------------------------------------------
-Project description
-
-DojoX A/V aims to bring audio and video capabilities to the Open Web, first
-by wrapping common media types (Flash and Quicktime) and then by providing
-easy to use objects to accomplish basic A/V tasks.  As of version 0.1, only
-the base is included (Flash and Quicktime embedding mechanisms); in the near
-future, usable objects will appear, both in raw programmatic form and also with
-Dijit-compatible wrappers.
--------------------------------------------------------------------------------
-Dependencies:
-
-DojoX A/V depends on dojox.embed, and uses Flash movies created in the deft
-project using Flex OSS 3.  You do not need any of the deft code; compiled
-movies are included with dojox.av.  If you want to modify the actual movies,
-you can look in the deft project (under the package deft.av).
--------------------------------------------------------------------------------
-Documentation
-
-TBD.
--------------------------------------------------------------------------------
-Included media:
-
-Video:
-test/video/Grog.flv and test/video/OldMan.flv are both created by Mike Wilcox
-and may be freely used and distributed in any way. I only ask for credit if
-widely shown.
-
-Audio:
-test/audio/Ola.mp3, test/audio/Hio.mp3, test/audio/FuzzWah.mp3 are from a
-sounds effects CD and are not to be redistributed. They will most likely
-be swapped out when a better open source option is avaialable.
-
--------------------------------------------------------------------------------
-Installation instructions
-
-Grab the following from the Dojo SVN Repository:
-
-http://svn.dojotoolkit.org/src/dojox/trunk/embed/*
-http://svn.dojotoolkit.org/src/dojox/trunk/av/*
-
-Install into the following directory structure:
-/dojox/av/
-
-...which should be at the same level as your Dojo checkout.
-
--------------------------------------------------------------------------------
-Change history
-
-2008-01-15	Initial checkin, with basic movie embedding code.
-2008-06-04	Removed the base code, after moving it into dojox.embed and modifying it.
-2008-08-14  Implemented FLVideo for Flash Video 
-2009-02-08  Implemented FLAudio for Flash Audio

data/vendor/assets/javascripts/dojox/av/widget/resources/PlayButton.html

@@ -1,3 +0,0 @@
-<div class="PlayPauseToggle Pause" dojoAttachEvent="click:onClick">
-    <div class="icon"></div>
-</div>

data/vendor/assets/javascripts/dojox/av/widget/resources/Player.html

@@ -1,20 +0,0 @@
-<div class="playerContainer">
-	<div class="PlayerScreen" dojoAttachPoint="playerScreen"></div>
-	<table class="Controls">
-		<tr>
-			<td colspan="2" dojoAttachPoint="progressContainer"></td>
-		</tr>
-		<tr>
-			<td class="PlayContainer" dojoAttachPoint="playContainer"></td>
-			<td class="ControlsRight">
-			<table class="StatusContainer">
-				<tr dojoAttachPoint="statusContainer">
-				</tr>
-				<tr>
-					<td colspan="3" class="ControlsBottom" dojoAttachPoint="controlsBottom"></td>
-				</tr>
-			</table>
-		</td>
-		</tr>
-	</table>
-</div>

data/vendor/assets/javascripts/dojox/av/widget/resources/ProgressSlider.html

@@ -1,6 +0,0 @@
-<div class="Progress" dojoAttachEvent="mousedown:startDrag">
-    
-    <div class="ProgressLoaded" dojoAttachPoint="progressLoaded"></div>
-    <div class="ProgressPosition" dojoAttachPoint="progressPosition"></div>
-	<div class="ProgressHandle" dojoAttachPoint="handle" dojoAttachEvent="mouseover:handleOver, mouseout:handleOut"></div>
-</div>

data/vendor/assets/javascripts/dojox/av/widget/resources/Status.html

@@ -1,7 +0,0 @@
-<table class="Status">
-    <tr>
-        <td class="Time"><span dojoAttachPoint="timeNode">0.00</span></td>
-        <td class="Status"><div dojoAttachPoint="titleNode">Loading...</div></td>
-        <td class="Duration"><span dojoAttachPoint="durNode">0.00</span></td>
-    </tr>
-</table>

data/vendor/assets/javascripts/dojox/av/widget/resources/VolumeButton.html

@@ -1,7 +0,0 @@
-<div class="Volume" dojoAttachEvent="mousedown:onShowVolume">
-	<div class="VolumeSlider" dojoAttachPoint="volumeSlider">
-    	<div class="VolumeSliderBack" dojoAttachPoint="volumeSliderBack"></div>
-    	<div class="VolumeSliderHandle" dojoAttachPoint="handle" dojoAttachEvent="mousedown:startDrag, mouseup:endDrag, mouseover:handleOver, mouseout:handleOut"></div>	
-    </div>
-    <div class="icon"></div>
-</div>

data/vendor/assets/javascripts/dojox/calc/Readme.txt

@@ -1,175 +0,0 @@
-Dojo Toolkit Graphing Calculator Project Readme
-Author: Jason Hays
-Trac ID: jason_hays22
-
-Contents:
-	Expressions
-	Variables, Functions, and uninitializing variables
-	toFrac in GraphPro
-	Numbers and bases
-	Graphing equations
-	Substitutes for hard to type characters
-	Making Functions
-	Decimal points, commas, and semicolons in different languages
-	Important mathematical functions
-
-
-
----------------Expressions----------------
-The calculator has the ability to simplify a valid expression.
-With Augmented Mathematical Syntax, users are allowed to use nonstandard operators in their expressions.  Those operators include ^, !, and radical.
-
-^ is used for exponentiation.
-	It is a binary operator, which means it needs a number on both the left and right side (like multiplication and division)
-	2^5 is an example of valid use of ^, and represents two to the power of five.
-
-! is used for factorial.
-	It supports numbers that are not whole numbers through the use of the gamma function.  It uses the number on its left side.  Both 2! and 2.6! are examples of valid input in America. (2,6! is valid in some nations)
-
-radicals can be used for either square root or various other roots.
-	to use it as a square root sign, there should only be a number on its right.  If you put a number on the left as well, then it will use that number as the root.
-
-To evaluate an expression, type in a valid expression, such as 2*(10+5), into the input box.  If you are using GraphPro, then it is the smaller text box.
-	After you have chosen an expression, press Enter on either your keyboard or on the lower right of the calculator.
-		If it did not evaluate, make sure you correctly closed your parentheses.
-	In the Standard calculator, the answer will appear in the input box, in GraphPro, the answer will appear in the larger text box above.
-	On the keyboard, you can navigate through your previous inputs with the up and down arrow keys.
-
-If you enter an operator when the textbox is empty or highlighted (like *) then Ans* should appear.  That means the answer you got before will be multiplied by whatever you input next.
-So try Ans*3.  Whenever you start the calculator, Ans is set to zero.
-
-
---------------Variables, Functions, and uninitializing variables----------------
-A variable is basically something that stores a value.  If you saw Ans in the previous example, you've also seen a variable.
-If you want to store your own number somewhere, you'll need to use the = operator.
-
-	Valid variable and function names include cannot start with numbers, do not include spaces, but can start with the alphabet (a-z or A-Z) and can have numbers within the names "var1" is a valid name
-
-	Input "myVar = 2" into the textbox and press "Enter."  You've just saved a variable.  Now if you ever type myVar into an expression, 2 will appear (unless you change it to something else).
-	Variables are best used to store Ans.  Ans is overridden whenever you evaluate an expression, so it is good to store the value of Ans somewhere else before it is overridden.
-
-	If you want a variable (like myVar) to become empty, or undefined, you just need to set it equal to undefined.
-	Now try "myVar = undefined"  Now myVar is no longer defined.
-
-	Functions are very useful for finding answers and gathering data.
-		You can use functions by inputting their name and their arguments.
-		For this example, I'll be using the functions named "sqrt" and "pow"
-
-		sqrt is a function with one argument.  That argument has a name too, its name is 'x.' x is a very common name amongst built in functions
-			So, let's run a function.  Input "sqrt" then input a left parenthesis (all arguments of a function go within parentheses).  Now type a value for x, like 2.
-			Now close the parentheses with the right parenthesis.  If you used 2, you should have "sqrt(2)" in the text box.  If you press enter, you should get the square root of 2 back from the calculator.
-
-		Now for "pow" it has two arguments 'x' and 'y'
-			Type in "pow(" and pick a value for 'x' (I am picking 2 again)
-			but now, you need to separate the value you gave x with a list separator.  Depending on your location, it is either a comma or a semicolon.  I'm in America, and I use commas.
-			by this point, I have "pow(2,"
-			Now we need a value for 'y' (I'm using 3).  Put a ')' and now I have 'pow(2,3)'
-			Press Enter, and, following my example, you should get 8
-
-		In this calculator, there are several ways to input arguments.
-			You've already seen the first way, just input numbers in a specific order based on the names.
-
-			The second way is with an arbitrary order, and storage.
-			With 'pow' I can input "pow(y=3, x=2)" and get the exact answer as before.  x and y will retain their assigned values, so you will need to set them to undefined it you want to try the next way.
-
-			The third way is to let the calculator ask you for the values.  Input "pow()"  If the values have been assigned globally, then it will use those values, but otherwise, it will ask for values of x and y.  They will not be stored globally this way.
-
-	I'll go ahead and mention that because of the way the calculator parses, underscores should not be used to name a variable like _#_ (where # is an integer of any length) 
-
----------------toFrac()----------------
-toFrac is a function that takes one parameter, x, and converts it to a fraction for you.  It is only in GraphPro, not the Standard mode.
-	It will try to simplify pi, square roots, and rational numbers where the denominator is less than a set bound (100 right now).
-	Immediately after the calculator starts, toFrac may seen slow, but it just needs to finish loading when the calculator starts.  After that, it will respond without delay.
-	For an example, input "toFrac(.5)" or (,5 for some).  It will return "1/2"
-	For a more complicated example, input "toFrac(atan(1))" to get back "pi/4"  (atan is also known as "arc tangent" or "inverse tangent")
-
---------------Numbers and bases----------------
-This calculator supports multiple bases, and not only that, but non integer versions of multiple bases.
-	What is a base?  Well, the numbers you know and love are base 10.  That means that you count to all of the numbers up until 10 before you move on to add to the tenths place.
-		So, what about base 2?  All of the numbers up until 2 are 0 and 1.  If you want to type a base 2 number into the calculator, simply input "0b" (meaning base 2) followed by some number of 1's and 0's. 0b101 is 5 in base 10
-
-		Hexadecimal is 0x, and octal is 0o, but i won't go into too much detail on those here.
-		If you want an arbitrary integer base, type the number in the correct base, insert '#' and put the radix on the end.  ".1#3" is the same as 1/3 in base 10
-			Because there is not yet cause for it, you cannot have a base that is not a whole number.
-
---------------Graphing Equations----------------
-First thing is first, in GraphPro only, the "Graph" button in the top left corner opens the Graph Window
-	So, now you should see a single text box adjacent to "y="
-	Type the right side of the equation using 'x' as the independent variable.
-	"sin(x)" for example.  To Graph it, make sure the checkbox to the left of the equation is selected, and press the Draw Selected button.
-	You can change the color in the color tab.  By default, it is black.  Under window options, you can change the window size and x/y boundaries
-
-	Let's add a second function.  Go to the Add Function button, select the mode you want, and press Create.  Another input box will appear.
-	If you selected x= as the Mode, then y is the independent variable for the line (an example is "x=sin(y)").
-		If you want to erase, check the checkboxes you want to erase, and press "Erase Selected"
-		And similarly, Delete Selected will delete the chosen functions
-
-	"Close" will terminate the Graph Window completely
-
----------------Substitutes for hard to type characters---------------
-Some characters are not simple to add in for keyboard users, so there are substitutes that are much easier to add into the text box.
-
-	pi or PI can be used in place of the special character for it.
-	For epsilon, eps or E can be used.
-	radical has replacement functions.  sqrt(x) or pow(x,y) can be used instead.
-
---------------Making Functions-----------------
-My favorite part.  Before we start, I'll mention that Augmented Mathematical Syntax is allowed in the Function Generator (yay).
-	Ok, now the bad news: to prevent some security issues, keywords new and delete are forbidden.
-	Sorry, it is a math calculator, not a game container; not that that would be so bad, but it is to keep it from being used for some evil purposes.
-
-	Ok, onto function making.  Most JavaScript arithmetic is supported here, but, some syntax was overlapping mathematical syntax, so ++Variable no longer increases the contents of Variable because of ++1, but Variable++ does increase it (same deal with --)
-		Strings have incredibly limited support. Objects have near zero support
-	So, let's make a Function:
-		Press the "Func" button.  A Function Window should pop up.
-		Enter a name into the "functionName" box.  (it must follow the name guidelines in the variables section)  I'm putting myFunc
-		Enter the variables you want into the arguments box (I'll put "x,y" so I have two arguments x and y)
-		Now enter the giant text box.
-		Type "return " and then the expression you want to give to the calculator.  I'm putting "return x*2 + y/2"
-		Then press Save.  Now your function should appear in the functionName list and you can call it in the Calculator.
-
-		If you want to Delete a function you made, select it in the function Name list, and then press Delete.
-		If you altered a previously saved function (and haven't saved over the old one) you can reset the text back to its original state with the Reset button.
-		Clear will empty out all of the text boxes in the Function Window
-		Close terminates the Function Window
-
----------------Decimal points, commas, and semicolons in different languages----------------
-In America, 3.5 is three and one half. Comma is used to separate function parameters and list members.
-
-In some nations, 3,5 is three and one half.  In lists, ;'s are used to separate its members.
-So, when you evaluate expressions, 3,5 will be valid, but in the function generator, some ambiguous texts prevent me from allowing the conversion of that format to JavaScript.  So I cannot parse it in the Function Generator.
-And here is my example:
-var	i = 3,5;
-	b = 2;
-I cannot discern whether the semicolon between i and b are list separators or the JavaScript character for end the line.  b could be intended as a global variable, and i is a local variable, but I don't know that.  So language conversion isn't supported in Function Making.
-
---------------Important mathematical Functions---------------
-Here is a list of functions you may find useful and their variable arguments:
-
-sqrt(x)	returns the square root of x
-x is in radians for all trig functions
-sin(x)	returns the sine of x
-asin(x)	returns the arc sine of x
-cos(x)	returns the cosine of x
-acos(x)	returns the arc cosine of x
-tan(x)	returns the tangent of x
-atan(x)	returns the arc tangent of x
-
-atan2(y, x)	returns the arc tangent of y and x
-Round(x)	returns the rounded integer form of x
-Int(x)		Cuts off the decimal digits of x
-Ceil(x)		If x has decimal digits, get the next highest integer
-
-ln(x)	return the natural log of x
-log(x)	return log base 10 of x
-pow(x, y) return x to the power of y
-
-permutations(n, r)	get the permutations for n choose r
-P(n, r) see permutations
-combinations(n, r)	get the combinations for n choose r
-C(n, r) see combinations
-
-toRadix(number, baseOut)	convert a number to a different base (baseOut)
-toBin(number)			convert number to a binary number
-toOct(number)			convert number to an octal number
-toHex(number)			convert number to a hexadecimal number

data/vendor/assets/javascripts/dojox/calc/_ExecutorIframe.html

@@ -1,533 +0,0 @@
-<html><head>
-<script type="text/javascript">
-Array.prototype._toString = Array.prototype.toString;
-Array.prototype.toString = function(){ return "[" + this._toString() + "]"; };
-
-Number.prototype._toString = Number.prototype.toString;
-Number.prototype.toString = function(radix){ if(!radix || radix==10){ return ""+this._toString() } if(radix==2){ return "0b"+this._toString(radix); } if(radix==8){ return "0o"+this._toString(radix); } if(radix==16){ return "0x"+this._toString(radix); } return this._toString(radix) + "#" + radix._toString(); };
-
-(function(){ // env is private
-	parseFloat = function(str){
-	var obj = null;
-	function getRadixObject(whole, numberStr, base){
-		obj = {number:numberStr, radix:base};
-		return "";
-	}
-	function getBaseString(whole, base, numberStr){
-		var baseNum = (base == '0b') ? 2 : (base == '0o') ? 8 : 16;
-		return numberStr+"#"+baseNum;
-	}
-
-
-	var str = str.replace(/(0b|0o|0x)(([0-9a-zA-Z]+\.[0-9a-zA-Z]*|\.[0-9a-zA-Z]+|[0-9a-zA-Z]+))/, getBaseString);
-
-	var radix;
-
-	var poundRegExp = /([0-9a-zA-Z]+\.[0-9a-zA-Z]*|\.[0-9a-zA-Z]+|[0-9a-zA-Z]+)\#([0-9a-zA-Z]+)/g;
-	if(poundRegExp.test(str)){
-		// define obj in getRadixObject
-		str.replace(poundRegExp, getRadixObject);
-		radix = obj.radix;
-		str = obj.number;
-	}
-	if(!radix){
-		radix = 10;
-	}
-	var decimal = str.indexOf('.');
-	if(decimal>=0){
-		var left = str.substring(0,decimal);
-		if(left == ""){
-			left = "0";
-		}
-		var right = str.substring(decimal+1, str.length);
-		if(right == ""){
-			right = "0";
-		}
-		var num = parseInt(left, radix);
-
-		var dec = parseInt(right, radix);
-		var length = dec._toString().length;
-		dec /= Math.pow(radix, right.length);
-		return num+dec;
-	}
-	return parseInt(str, radix);
-};
-
-	var env = {
-		window: undefined, "delete": undefined, "new": undefined, // invalidate access to the globals for security so that window.blah is invalid as is delete window
-
-		prompt: function(label, defaultValue){
-			// summary:
-			//		prompt the user for input without making IE8 mad.
-			// label:
-			//		the String name of the variable you are asking the user to input
-			// defaultValue: primitive
-			//		the prompt will show this value initially
-
-			label = label || '';
-			defaultValue = defaultValue || '';
-			try{
-				return this.outerPrompt(label, defaultValue);
-			}catch(e){
-				return window.prompt(label, defaultValue);
-			}
-		},
-		val: function(local, name, obj){
-			// summary:
-			//		allow the user to use locals, globals, or give input for undefined values
-			// local: a primitive object
-			//		what value might've been passed to val as a local parameter.
-			// name: String
-			//		String name of the object.  It is passed to see if there is an available global or to set the global.
-			var objValue = obj[name];
-			local = (objValue == undefined) ? (local == undefined ? window[name] : local) : objValue ;
-
-			if(typeof local == 'undefined'){
-				if(obj.graphing){
-					return undefined;
-				}
-				local=this.prompt('Enter the value for ' + name, undefined, name);
-
-				return local == null ? undefined : (isNaN(Number(local)) ? local : Number(local));
-			}
-			return local;
-		},
-		_makeKeywordsLiteral: function (text){
-			// summary:
-			//		surround reserved words with hex characters
-
-			// ==, then >=. the <=, then !=, then = and surround them with \x0n first
-			text = text.replace(/(!=(?!=)|==|>=|<=|=)/g, "\x02$1\x02");
-			return text.replace(/\b(abstract|boolean|break|byte|case|catch|char|class|const|continue|debugger|default|do|double|else|enum|export|extends|false|final|finally|float|for|function|goto|if|implements|import|in| instanceof|int|interface|long|native|null|package|private|protected|public|return|short|static|super| switch|synchronized|this|throw|throws|transient|true|try|typeof|var|void|volatile|while|with)\b/g, "\x02$1\x02");
-		},
-		switchToGermanNumbers: function(text){
-			// summary:
-			//		change the format of some javascript allowed numbers to an alternate form 3.5 goes to 3,5
-			var num = 0;
-			var numbers = [];
-			function substituteCommas(whole, junk, text){
-				numbers['_'+num+'_'] = text.replace(/\,/g, ';');
-				return junk+'_'+(num++)+'_';
-			}
-			function substituteNumbers(wholematch, stuff, junk, text, stuff2){
-				return stuff+numbers[text]+stuff2;
-			}
-			if(typeof text != "string"){
-				text = text.toString();
-			}
-			if(text.indexOf('\x02')<0){
-				text = this._makeKeywordsLiteral(text);
-				//text = text.replace(/(!=(?!=)|==|>=|<=|=)/g, "\x02$1\x02");
-			}
-
-			// same as semiColonRegExp
-			var commaRegExp = /([^\x02\s]*)(\([^\(\)]+\)|\[[^\[\]]+\])/;
-			while(commaRegExp.test(text)){
-				text = text.replace(commaRegExp , substituteCommas);
-			}
-
-			while(/((\W)*)(\_[0-9]+\_)((\W)*)/.test(text)){
-				text = text.replace(/((\W)*)(\_[0-9]+\_)((\W)*)/g, substituteNumbers);
-			}
-
-			text = text.replace(/([0-9]*)\.([0-9]+)/g, "$1"+','+"$2");
-
-			// get rid of keyword characters (duplicate code from parse())
-			return text.replace(/\x02((.|\s)*?)\x02/g, "$1");
-		},
-		normalizeTextLanguage: function(text){
-			// summary:
-			//		change text to use javascript list separators and decimal points instead of commas
-			// text: String
-			//		string like "pow(3,1; 4);"
-			//		for that input, this method should return "pow(3.1, 4);"
-
-			var num = 0;
-			var numbers = [];
-			function substituteSemicolons(whole, junk, text){
-				numbers['_'+num+'_'] = text.replace(/\;/g, ',');
-				return junk+'_'+(num++)+'_';
-			}
-			function substituteNumbers(wholematch, stuff, junk, text, stuff2){
-				return stuff+numbers[text]+stuff2;
-			}
-			if(text.indexOf('\x02')<0){
-				text = this._makeKeywordsLiteral(text);
-			}
-			// change all comma-type decimals into periods
-			text = text.replace(/([0-9]*)\,([0-9]+)/g, "$1"+'.'+"$2");
-			//alert(text);
-			var semiColonRegExp = /([^\x02\s]*)(\([^\(\)]+\)|\[[^\[\]]+\])/; // /([^\x02\s]+)(\([^\(\)]+\)|\[[^\[\]]+\])/; // /[^\x02\s]+\([^\(\)]+\)|[^\x02\s]+\[[^\[\]]+\]/; // /[^\x02]\s*\([^\(]+\)/;
-			while(semiColonRegExp.test(text)){
-				text = text.replace(semiColonRegExp, substituteSemicolons);
-			}
-			while(/((\W)*)(\_[0-9]+\_)((\W)*)/.test(text)){
-				text = text.replace(/((\W)*)(\_[0-9]+\_)((\W)*)/g, substituteNumbers);
-			}
-			// get rid of keyword characters (duplicate code from parse())
-			return text.replace(/\x02((.|\s)*?)\x02/g, "$1");
-		},
-		preparse: function(text){
-			// summary:
-			//		change the numbers to javascript allowed numbers if it is from a different locale
-			if(!this.isJavaScriptLanguage){
-				text = this.normalizeTextLanguage(text);
-			}
-			return text;
-		},
-		// parseFloat(Number(4.5).toString(3)) should return 4.5
-
-		postparse: function(text){
-			// summary:
-			//		make the javascript numbers match the locale
-			if(!this.isJavaScriptLanguage){
-				text = this.switchToGermanNumbers(text);
-			}
-			return text;
-		},
-		toDecimalRegExp: function(whole, base, number){
-			// summary:
-			//		get the decimal number from a float
-			function getBase(base){
-				switch(base){
-					case '0b':
-						return 2;
-					case '0o':
-						return 8;
-					case '0x':
-						return 16;
-					default:
-						return 10;
-				}
-			}
-			//return parseInt(base, getBase(base));
-			return parseFloat(base+number);
-		},
-		parse: function(text){
-			// summary:
-			//		This parses augmented mathematical syntax and converts it to executable JavaScript.
-			// text: String
-			//		should be a String which represents an expression, a function, a number, etc
-
-			// this array holds the substitutions that represent an expression's parentheses and functions in a simplified way.
-			var	numbers = [],
-				// characters
-				functionContentsChar = '\x03',
-			// these are the regular expression needed to find and replace operators
-				factorialRE = /((\w|\.)+)\s*\!/,
-				unaryRightsideRE = /(^|[\+\-\/\*\!\^\u221A]+\s*)([\+\-]+)\s*((\w|\.)+)(?!.*[\+\-])/,
-				unaryRE = /(^|[^a-zA-Z0-9_\.\s]+\s*)([\+\-]+|\u221A)\s*((\w|\.)+)/,		 // /(^|[^a-zA-Z0-9_\.]\s*)([\+\-]+|\u221A)\s*((\w|\.)+)/,
-				caretRE = /((\w|\.)+)\s*([\^])\s*((\w|\.)+)/, // /((\w|\.)+)\s*([\^])\s*(-?\s*(\w|\.)+)/, 
-				radicalRE = /((\w|\.)+)\s*(\u221A)\s*([+-]?\s*(\w|\.)+)/, // /((\w|\.)+)\s*(\u221A)\s*([+-]?\s*(\w|\.)+)(?!.*\u221A)/,
-				binaryHighRE = /((\w|\.)+)\s*([*/])\s*((\w|\.)+)/,
-				binaryLowRE = /((\w|\.)+)\s*([\+\-])+\s*((\w|\.)+)/;
-
-			// get rid of all new and delete statements
-			text = exterminateNewAndDelete(text);
-			// make all keywords and operators literal (like '!=' or 'return') by surrounding them with unprintable characters
-			text = this._makeKeywordsLiteral(text);
-
-
-			function getBaseTen(whole, numberStr, base){
-				return ""+parseFloat(numberStr+"#"+parseInt(base));
-			}
-			text = text.replace(/(0b)([0-1]+\.[0-1]*|\.[0-1]+|[0-1]+)/g, this.toDecimalRegExp);
-			text = text.replace(/(0o)([0-7]+\.[0-7]*|\.[0-7]+|[0-7]+)/g, this.toDecimalRegExp);
-			text = text.replace(/(0x)([0-9a-zA-Z]+\.[0-9a-zA-Z]*|\.[0-9a-zA-Z]+|[0-9a-zA-Z]+)/g, this.toDecimalRegExp);
-
-			text = text.replace(/([0-9a-zA-Z]+\.[0-9a-zA-Z]*|\.[0-9a-zA-Z]+|[0-9a-zA-Z]+)\#([0-9a-zA-Z]+)/g, getBaseTen);
-
-			// parse the input to form JavaScript
-			return MathParser(text);
-
-			function MathParser(text){
-				// Pi is better represented by \u03C0, but isn't computable
-				text = text.replace(/\u03C0/g,"Math.PI");
-				text = text.replace(/\u03F5/g,"Math.E");
-
-				// Microsoft word will give you these '\u2013' for a subtraction sign sometimes, so I'll fix that here
-				text = text.replace(/\u2013/g, "-");
-				// add unreadable characters in front of functions so it is easier to manipulate
-				text = text.replace(/(((\w|\.)+\s*)\()/g,putFuncChar);
-
-				// change 10e-10 or 10e10 or 10e+10 to an constant right away
-				text = scientificNotationSimplifier(text);
-				// recursively track down and replace all simplified parts of the expression until everything is simple; then move the simple text into the correct JavaScript format
-				text = parseRecursive(text);
-				// now resubstitute the real text back into the string now that it is arranged correctly
-				while (hasArrayIndexBasedOnUnderscore(text)){
-					text  = text.replace(/\_(\d+)\_/g, function(whole, one){return numbers[parseInt(one)]});
-				}
-				// get rid of the function character from the functions now
-				text = text.replace(/\x01/g,"");
-				// get rid of keyword characters too
-				text = text.replace(/\x02((.|\s)*?)\x02/g, "$1");
-				return text;
-			}
-			function exterminateNewAndDelete(text){
-				return text.replace(/\b(delete|new|this\.*)\b/, "");
-			}
-			// A simple grouping has no parentheses inside the initial pair.
-			function isSimpleGrouping(text){
-				return (/^\([^()]*\)|\W\([^()]*\)/).test(text);
-			}
-			function ReplaceSimpleGrouping(text){
-				return text.replace((/(^|\W)(\([^()]*\))/), replaceWithNum);
-			}
-			function replaceWithNum(wholeMatch, partMatch1, partMatch2){
-				numbers.push(partMatch2);
-				return partMatch1+"_"+(numbers.length-1)+"_";
-			}
-			function replaceFuncWithNum(wholeMatch){
-				numbers.push(wholeMatch);
-				return "_"+(numbers.length-1)+"_";
-			}
-			// A simple function has no parentheses within its parentheses, and has the special character \x01 leading up to the name and (...)
-			function isSimpleFunction(text){
-				return (/\x01((\w|\.)+\s*)\([^()]*\)/).test(text);
-			}
-			function ReplaceSimpleFunction(text){
-				return text.replace(/\x01((\w|\.)+\s*)\([^()]*\)/, replaceFuncWithNum);
-			}
-			function FactorialParser(text){
-				// loop this untill all ! are gone (in main)
-				return text.replace(factorialRE, "\x01"+"factorial($1)");
-			}
-			function putFuncChar(wholematch){
-				return '\x01'+wholematch;
-			}
-			function putInPiece(wholematch){
-				return numbers[currentNum];
-			}
-
-			function caretParser(text){
-				return text.replace(caretRE, replaceBinaryOp);
-			}
-			// the unary radical is inside the unaryOperatorParse(text) function
-			function radicalOperatorParse(text){
-				return text.replace(radicalRE, replaceBinaryOp);
-			}
-			function replaceBinaryOp(wholeMatch, operand1, nothing1, operator, operand2){
-
-				switch(operator.charAt(0)){
-					case '^':
-						return "\x01"+"pow("+operand1+","+operand2+")";
-					case '\u221A':
-						return "\x01"+"pow("+operand2+", 1/"+operand1+")";
-					case '*':
-					case '/':
-						return replaceFuncWithNum(wholeMatch);
-					case '+':
-					case '-':
-					case 'e':
-						return replaceFuncWithNum(simplifyPlusAnsMinus(wholeMatch));
-				}
-			}
-			// e is treated as a binary operator
-			function scientificNotationSimplifier(text){
-				//return text.replace(/((\w|\.)+)\s*([\e])\s*([+-]*\s*(\w|\.)+)/g, replaceBinaryOp);
-				return text.replace(/(([0-9]+\.?[0-9]*))(e)([+-]*([0-9]+))/g, replaceBinaryOp);
-			}
-			// this handles * and /
-			function binaryHighPriorityOperatorParse(text){
-				return text.replace(binaryHighRE, replaceBinaryOp);
-			}
-			// this handles + and - with two operands
-			function binaryLowPriorityOperatorParse(text){
-				return text.replace(binaryLowRE, replaceBinaryOp);
-			}
-			// this replaces the one operand +'s, -'s, and radicals
-			function replaceUnaryOp(wholeMatch, garbage, operator0, operand0){
-				// see what operator it is
-				switch(operator0.charAt(0)){
-					case '\u221A':
-						return garbage+"\x01"+"sqrt("+operand0+")";
-					case '+':
-					case '-':
-						return garbage+replaceFuncWithNum(simplifyPlusAnsMinus(wholeMatch.substr(garbage.length)));
-				}
-			}
-			// this handles one operand operators -, +, radical
-			function unaryOperatorParse(text){
-				return text.replace(unaryRE, replaceUnaryOp);
-			}
-			// this handles one operand operators on the right side of everything
-			function unaryOperatorRightsideParse(text){
-				return text.replace(unaryRightsideRE, replaceUnaryOp);
-			}
-			function parseRecursive(text){
-				// keep going until there is nothing left that can be simplified
-				while (isSimpleGrouping(text)||isSimpleFunction(text)||factorialRE.test(text)||caretRE.test(text)||radicalRE.test(text)||unaryRE.test(text)||binaryHighRE.test(text)||binaryLowRE.test(text)){
-
-					var sTextOrginal = text;
-
-					if(isSimpleFunction(text)){
-						var debugText = text;
-
-						text = ReplaceSimpleFunction(text);
-						var	s = numbers[numbers.length-1],
-							pL = s.indexOf("("),
-							funcName = s.substring(s.indexOf("\x01")+1, pL),//take out the function character
-							content = s.substring(pL+1, s.length-1);
-
-						numbers[numbers.length-1] = funcName+"("+parseRecursive(functionContentsChar+content)+")";
-						continue;
-					}
-					if(isSimpleGrouping(text)){
-						text = ReplaceSimpleGrouping(text);
-						var	s = numbers[numbers.length-1],
-							content = s.substring(1, s.length-1);
-						numbers[numbers.length-1] = "("+parseRecursive(content)+")";
-						continue;
-					}
-
-					// factorials must come first for 5^2! cases, it equals 25
-					text = FactorialParser(text);
-					if(text!=sTextOrginal){
-						continue;
-					}
-
-					text = caretParser(text);
-					if(text!=sTextOrginal){
-						continue;
-					}
-
-					text = radicalOperatorParse(text);
-					if(text!=sTextOrginal){
-						continue;
-					}
-					text = unaryOperatorRightsideParse(text);
-					if(text!=sTextOrginal){
-						// put parentheses around the unary operators so 0--2 will pass
-						numbers[numbers.length-1] = "("+numbers[numbers.length-1]+")";
-						continue;
-					}
-					text = unaryOperatorParse(text);
-					if(text!=sTextOrginal){
-						// put parentheses around the unary operators so 0--2 will pass
-						numbers[numbers.length-1] = "("+numbers[numbers.length-1]+")";
-						continue;
-					}
-
-					text = binaryHighPriorityOperatorParse(text);
-					if(text!=sTextOrginal){
-						continue;
-					}
-					text = binaryLowPriorityOperatorParse(text);
-					if(text!=sTextOrginal){
-						continue;
-					}
-					// it should never ever make it to this point.  If it does, I'll want to know about it.
-					throw("Parse Error");
-				}
-				// make assignments within function calls be arranged to be (x=y, undefined)
-				if(text.charAt(0) == functionContentsChar){
-					text = text.substring(1, text.length);
-					if(text.indexOf('=') >= 0){
-						text = ReplaceFunctionContentAssignments(text);
-					}
-				}
-
-				return text;
-			}
-			function ReplaceFunctionContentAssignments(text){
-				return text.replace(/((\w|\.)+)\x02=\x02((\w|\.)+)/g, "("+"$1"+'\x02=\x02'+"$3"+", {_name:'"+"$1"+"', _value:"+"$3"+"})");
-			}
-			function hasArrayIndexBasedOnUnderscore(text){
-				return /\_\d+\_/.test(text);
-			}
-			
-			function simplifyPlusAnsMinus(text){
-				function hasUnsimplifiedPlusMinus(text){
-					return /\-\s*\-/.test(text)||/\+\s*\+/.test(text)||/\+\s*\-/.test(text)||/\-\s*\+/.test(text);
-				}
-				while(hasUnsimplifiedPlusMinus(text)){
-					text = text.replace(/((\-\s*\-)|(\+\s*\+))/g, "+");
-					text = text.replace(/((\+\s*\-)|(\-\s*\+))/g, "-");
-				}
-				return text;
-			}
-
-		},
-		eval: function(text){
-			// summary:
-			//		create an anonymous function to run the code the parser generates from the user input.
-			// text: String
-			//		is the user input that needs to be parsed
-
-			// this try catch is necessary to ensure that any incorrect input will receive NaN (it won't cause a self destruct from a user typo)
-			try{
-				var value = this.Function(undefined, '', 'return ' + text).call(this); // make sure it is called within the correct scope.
-				//value = ((value instanceof Array || typeof value == "array") ? ("["+value+"]") : value.toString())
-				return this.postparse(value);
-			}catch(e){
-				return NaN;
-			}
-		},
-		normalizedFunction: function(name, args, body){
-			// summary:
-			//		create an anonymous function to run the code the parser generates from the user input.
-			// name: String
-			//		this argument is simply a String that represents the name of the function being evaluated. It can be undefined, but in that case the function is a one time use.
-			// args: String
-			//		the function arguments
-			// body: String
-			//		the function body
-			var	argMultiVals = '',
-			// make an array of parameters with what's given (if nothing is given, make an empty array)
-				params = args ? (args||'').split(/\W+/) : [];
-
-			argMultiVals += 'var _localObjectContainer = {};\n'+
-						'for(var _objCnt = 0; _objCnt < arguments.length; _objCnt++){\n'+
-						'if(typeof arguments[_objCnt] == "object" && "_name" in arguments[_objCnt] && "_value" in arguments[_objCnt]){\n'+
-							'_localObjectContainer.graphing = arguments[_objCnt]._graphing;\n'+
-							'_localObjectContainer[arguments[_objCnt]._name]=arguments[_objCnt]._value;\n'+
-							'arguments[_objCnt]=undefined;\n}\n}\n';
-
-			// make the parameters fit into the val function so it can use either globals, locals, or if all are null, prompt the user for input
-			for(var i=0; i < params.length; i++){
-				var param = params[i];
-				argMultiVals += param + '=val(' + param + ',"' + param + '", _localObjectContainer);\n';
-				argMultiVals += 'if(typeof '+param+' == "undefined"){\n'+
-						'return null;}\n';
-			}
-			var _f_ = window.Function.apply(this,
-				[
-					args,
-					'with(Math){with(this.dojox.math){with(this){\n' +
-						argMultiVals +
-						this.parse(body) +
-					'\n}}}'
-				]
-			);
-			if(name){
-				return this[name] = _f_;
-			}
-			return _f_;
-		},
-		Function: function(name, args, body){
-			// summary:
-			//		create an anonymous function to run the code the parser generates from the user input.  It also normalizes the language format.
-			// name: String
-			//		this argument is simply a String that represents the name of the function being evaluated. It can be undefined, but in that case the function is a one time use.
-			// args: String
-			//		the function arguments
-			// body: String
-			//		the function body
-
-			body = this.preparse(body);
-			return this.normalizedFunction(name, args, body);
-
-		}
-	};
-	for(var i in window){
-        	if(!(i in env) && i != "alert" && i != "confirm"){ env[i] = undefined; } // invalidate access to the window object's attributes for security so that document.blah is invalid
-	}
-	frameElement.onload(env);
-})();
-</script>
-</head><body>
-<script type="text/javascript">
-	document.documentElement.removeChild(document.documentElement.firstChild); // remove HEAD to remove debugger access for extra security
-</script>
-</body></html>