RubyGems - envjs - Versions diffs - 0.1.7 → 0.2.0 - Mend

envjs 0.1.7 → 0.2.0

Files changed (187) hide show

data/.jslintrbrc +29 -0
data/.project +17 -0
data/CHANGELOG.rdoc +3 -0
data/DTD/xhtml-lat1.ent +196 -0
data/DTD/xhtml-special.ent +80 -0
data/DTD/xhtml-symbol.ent +237 -0
data/DTD/xhtml.soc +14 -0
data/DTD/xhtml1-frameset.dtd +1235 -0
data/DTD/xhtml1-strict.dtd +978 -0
data/DTD/xhtml1-transitional.dtd +1201 -0
data/DTD/xhtml1.dcl +192 -0
data/Makefile +7 -0
data/Manifest.txt +287 -0
data/{README → README.rdoc} +24 -3
data/Rakefile +196 -0
data/Wakefile +24 -0
data/build.properties +9 -0
data/build.xml +247 -0
data/gm/jquery.js +6002 -0
data/gm/mainx.js +2648 -0
data/gm/sensx.js +135 -0
data/gm/t.js +6 -0
data/gm/x.html +76 -0
data/htmlparser/BrowserTreeBuilder.java +456 -0
data/htmlparser/README +34 -0
data/htmlparser/build.sh +38 -0
data/jsl/jsl +0 -0
data/jsl/jsl.default.conf +129 -0
data/jsl/jsl.exe +0 -0
data/lib/envjs.rb +2 -0
data/lib/envjs/env.js +22 -3
data/lib/envjs/event_loop.js +2 -0
data/lib/envjs/static.js +155 -21
data/licenses/GPL-LICENSE.txt +278 -0
data/licenses/MIT-LICENSE.txt +20 -0
data/src/base64.js +80 -0
data/src/build.js +6 -0
data/src/cruft/bad.html +24 -0
data/src/cruft/dom.js +606 -0
data/src/cruft/element.js +297 -0
data/src/cruft/good.html +30 -0
data/src/cruft/good.js +32 -0
data/src/cruft/internal.js +81 -0
data/src/cruft/parser.js +458 -0
data/src/css/properties.js +293 -0
data/src/css/rule.js +22 -0
data/src/css/sizzle.js +717 -0
data/src/css/stylesheet.js +52 -0
data/src/dom/attr.js +55 -0
data/src/dom/cdatasection.js +31 -0
data/src/dom/characterdata.js +119 -0
data/src/dom/comment.js +30 -0
data/src/dom/doctype.js +9 -0
data/src/dom/document.js +553 -0
data/src/dom/dom.js +134 -0
data/src/dom/element.js +217 -0
data/src/dom/entities.js +273 -0
data/src/dom/exception.js +28 -0
data/src/dom/fragment.js +37 -0
data/src/dom/implementation.js +602 -0
data/src/dom/instruction.js +51 -0
data/src/dom/namednodemap.js +374 -0
data/src/dom/namespace.js +50 -0
data/src/dom/node.js +618 -0
data/src/dom/nodelist.js +195 -0
data/src/dom/parser.js +1207 -0
data/src/dom/text.js +73 -0
data/src/event/event.js +39 -0
data/src/event/mouseevent.js +4 -0
data/src/event/uievent.js +8 -0
data/src/html/a.js +110 -0
data/src/html/anchor.js +80 -0
data/src/html/area.js +57 -0
data/src/html/base.js +26 -0
data/src/html/blockquote-q.js +19 -0
data/src/html/body.js +19 -0
data/src/html/button.js +21 -0
data/src/html/canvas.js +14 -0
data/src/html/col-colgroup.js +49 -0
data/src/html/collection.js +72 -0
data/src/html/cookie.js +151 -0
data/src/html/del-ins.js +25 -0
data/src/html/div.js +28 -0
data/src/html/document.js +359 -0
data/src/html/element.js +380 -0
data/src/html/fieldset.js +19 -0
data/src/html/form.js +484 -0
data/src/html/frame.js +89 -0
data/src/html/frameset.js +25 -0
data/src/html/head.js +44 -0
data/src/html/html.js +0 -0
data/src/html/htmlparser.js +340 -0
data/src/html/iframe.js +26 -0
data/src/html/image.js +0 -0
data/src/html/img.js +62 -0
data/src/html/input-elements.js +307 -0
data/src/html/input.js +65 -0
data/src/html/label.js +26 -0
data/src/html/legend.js +19 -0
data/src/html/link.js +82 -0
data/src/html/map.js +22 -0
data/src/html/meta.js +37 -0
data/src/html/object.js +89 -0
data/src/html/optgroup.js +25 -0
data/src/html/option.js +97 -0
data/src/html/param.js +38 -0
data/src/html/script.js +122 -0
data/src/html/select.js +129 -0
data/src/html/style.js +31 -0
data/src/html/table.js +199 -0
data/src/html/tbody-thead-tfoot.js +91 -0
data/src/html/td-th.js +18 -0
data/src/html/textarea.js +25 -0
data/src/html/title.js +20 -0
data/src/html/tr.js +114 -0
data/src/intro.js +141 -0
data/src/outro.js +70 -0
data/src/parser/html5.detailed.js +10762 -0
data/src/parser/html5.min.js +503 -0
data/src/parser/html5.pretty.js +10815 -0
data/src/parser/intro.js +42 -0
data/src/parser/outro.js +9 -0
data/src/platform/core.js +323 -0
data/src/platform/johnson.js +479 -0
data/src/platform/rhino.js +327 -0
data/src/platform/static/intro.js +41 -0
data/src/platform/static/outro.js +30 -0
data/src/profile/aop.js +238 -0
data/src/profile/profile.js +402 -0
data/src/serializer/xml.js +21 -0
data/src/svg/animatedstring.js +25 -0
data/src/svg/document.js +25 -0
data/src/svg/element.js +22 -0
data/src/svg/locatable.js +17 -0
data/src/svg/rect.js +18 -0
data/src/svg/rectelement.js +24 -0
data/src/svg/stylable.js +49 -0
data/src/svg/svgelement.js +22 -0
data/src/svg/transformable.js +15 -0
data/src/window/css.js +15 -0
data/src/window/dialog.js +16 -0
data/src/window/document.js +28 -0
data/src/window/event.js +262 -0
data/src/window/history.js +62 -0
data/src/window/location.js +138 -0
data/src/window/navigator.js +48 -0
data/src/window/screen.js +53 -0
data/src/window/timer.js +21 -0
data/src/window/window.js +284 -0
data/src/window/xhr.js +127 -0
data/src/xpath/expression.js +49 -0
data/src/xpath/implementation.js +2482 -0
data/src/xpath/result.js +67 -0
data/src/xpath/util.js +551 -0
data/src/xpath/xmltoken.js +149 -0
data/src/xslt/COPYING +34 -0
data/src/xslt/ajaxslt-0.8.1/AUTHORS +1 -0
data/src/xslt/ajaxslt-0.8.1/ChangeLog +136 -0
data/src/xslt/ajaxslt-0.8.1/Makefile +49 -0
data/src/xslt/ajaxslt-0.8.1/README +102 -0
data/src/xslt/ajaxslt-0.8.1/TODO +15 -0
data/src/xslt/ajaxslt-0.8.1/dom.js +566 -0
data/src/xslt/ajaxslt-0.8.1/dom_unittest.html +24 -0
data/src/xslt/ajaxslt-0.8.1/dom_unittest.js +131 -0
data/src/xslt/ajaxslt-0.8.1/simplelog.js +79 -0
data/src/xslt/ajaxslt-0.8.1/test/xpath.html +18 -0
data/src/xslt/ajaxslt-0.8.1/test/xpath_script.js +45 -0
data/src/xslt/ajaxslt-0.8.1/test/xslt.html +58 -0
data/src/xslt/ajaxslt-0.8.1/test/xslt_script.js +33 -0
data/src/xslt/ajaxslt-0.8.1/unittestsuite.html +26 -0
data/src/xslt/ajaxslt-0.8.1/xmltoken.js +149 -0
data/src/xslt/ajaxslt-0.8.1/xmltoken_unittest.html +18 -0
data/src/xslt/ajaxslt-0.8.1/xmltoken_unittest.js +811 -0
data/src/xslt/ajaxslt-0.8.1/xpath_unittest.html +39 -0
data/src/xslt/ajaxslt-0.8.1/xpath_unittest.js +557 -0
data/src/xslt/ajaxslt-0.8.1/xpathdebug.js +234 -0
data/src/xslt/ajaxslt-0.8.1/xslt_unittest.html +138 -0
data/src/xslt/ajaxslt-0.8.1/xslt_unittest.js +68 -0
data/src/xslt/implementation.js +625 -0
data/src/xslt/processor.js +37 -0
data/src/xslt/util.js +449 -0
data/test/foo.html +8 -0
data/test/foo.js +40 -0
data/test/jquery.js +6002 -0
data/test/x.js +1 -0
data/test/y.js +1 -0
metadata +245 -14

data/src/html/element.js ADDED Viewed

@@ -0,0 +1,380 @@
+$debug("Defining HTMLElement");
+/*
+* HTMLElement - DOM Level 2
+*/
+var HTMLElement = function(ownerDocument) {
+    this.DOMElement = DOMElement;
+    this.DOMElement(ownerDocument);
+    this.$css2props = null;
+};
+HTMLElement.prototype = new DOMElement;
+__extend__(HTMLElement.prototype, {
+		get className() {
+		    return this.getAttribute("class")||'';
+	    },
+		set className(value) {
+		    return this.setAttribute("class",trim(value));
+	    },
+		get dir() {
+		    return this.getAttribute("dir")||"ltr";
+	    },
+		set dir(val) {
+		    return this.setAttribute("dir",val);
+	    },
+		get id(){
+		    return this.getAttribute('id');
+	    },
+		set id(id){
+		    this.setAttribute('id', id);
+	    },
+		get innerHTML(){
+		    return this.childNodes.xml;
+	    },
+		set innerHTML(html){
+		    //Should be replaced with HTMLPARSER usage
+            //$debug('SETTING INNER HTML ('+this+'+'+html.substring(0,64));
+            var doc = new HTMLDocument(this.ownerDocument.implementation,
+                                        this.ownerDocument._parentWindow,
+                                        "");
+// print("innerHTML",html);
+// try { throw new Error; } catch(e) { print(e.stack); }
+            var docstring = '<html><head></head><body>'+
+                '<envjs_1234567890 xmlns="envjs_1234567890">'
+                +html+
+                '</envjs_1234567890>'+
+                '</body></html>';
+            doc.in_inner_html = true;
+            this.ownerDocument._parentWindow.parseHtmlDocument(docstring,doc,null,null,true);
+            var parent = doc.body.childNodes[0];
+			while(this.firstChild != null){
+			    this.removeChild( this.firstChild );
+			}
+			var importedNode;
+            var pn = this;
+            while(pn.parentNode) {
+                pn = pn.parentNode;
+            }
+            // print(this,pn,this.ownerDocument);
+            try{
+                if (pn === this.ownerDocument) {
+                    this.ownerDocument.in_inner_html = true;
+                    // print("yup");
+                }
+			    while(parent.firstChild != null){
+	            importedNode = this.importNode(
+	                parent.removeChild( parent.firstChild ), true);
+			        this.appendChild( importedNode );
+		        }
+            } finally {
+                if (pn === this.ownerDocument) {
+                    // print("nope");
+                    this.ownerDocument.in_inner_html = false;
+                }
+            }
+		    //Mark for garbage collection
+		    doc = null;
+		},
+        get innerText(){
+            return __recursivelyGatherText__(this);
+        },
+        set innerText(newText){
+			while(this.firstChild != null){
+			    this.removeChild( this.firstChild );
+			}
+            var text = this.ownerDocument.createTextNode(newText);
+            this.appendChild(text);
+        },
+		get lang() {
+		    return this.getAttribute("lang");
+	    },
+		set lang(val) {
+		    return this.setAttribute("lang",val);
+	    },
+		get offsetHeight(){
+		    return Number(this.style["height"].replace("px",""));
+		},
+		get offsetWidth(){
+		    return Number(this.style["width"].replace("px",""));
+		},
+		offsetLeft: 0,
+		offsetRight: 0,
+		get offsetParent(){
+		    /* TODO */
+		    return;
+	    },
+		set offsetParent(element){
+		    /* TODO */
+		    return;
+	    },
+		scrollHeight: 0,
+		scrollWidth: 0,
+		scrollLeft: 0,
+		scrollRight: 0,
+		get style(){
+		    if(this.$css2props === null){
+	            this.$css2props = new CSS2Properties(this);
+	        }
+	        return this.$css2props;
+		},
+        set style(values){
+		    __updateCss2Props__(this, values);
+        },
+		setAttribute: function (name, value) {
+            DOMElement.prototype.setAttribute.apply(this,[name, value]);
+		    if (name === "style") {
+		        __updateCss2Props__(this, value);
+		    }
+		},
+		get title() {
+		    return this.getAttribute("title");
+	    },
+		set title(value) {
+		    return this.setAttribute("title", value);
+	    },
+		get tabIndex(){
+            var ti = this.getAttribute('tabindex');
+            if(ti!==null)
+                return Number(ti);
+            else
+                return 0;
+        },
+        set tabIndex(value){
+            if(value===undefined||value===null)
+                value = 0;
+            this.setAttribute('tabindex',Number(value));
+        },
+		//Not in the specs but I'll leave it here for now.
+		get outerHTML(){
+		    return this.xml;
+	    },
+	    scrollIntoView: function(){
+	        /*TODO*/
+	        return;
+        },
+		onclick: function(event){
+            return __eval__(this.getAttribute('onclick')||'', this);
+	    },
+		ondblclick: function(event){
+            return __eval__(this.getAttribute('ondblclick')||'', this);
+	    },
+		onkeydown: function(event){
+            return __eval__(this.getAttribute('onkeydown')||'', this);
+	    },
+		onkeypress: function(event){
+            return __eval__(this.getAttribute('onkeypress')||'', this);
+	    },
+		onkeyup: function(event){
+            return __eval__(this.getAttribute('onkeyup')||'', this);
+	    },
+		onmousedown: function(event){
+            return __eval__(this.getAttribute('onmousedown')||'', this);
+	    },
+		onmousemove: function(event){
+            return __eval__(this.getAttribute('onmousemove')||'', this);
+	    },
+		onmouseout: function(event){
+            return __eval__(this.getAttribute('onmouseout')||'', this);
+	    },
+		onmouseover: function(event){
+            return __eval__(this.getAttribute('onmouseover')||'', this);
+	    },
+		onmouseup: function(event){
+            return __eval__(this.getAttribute('onmouseup')||'', this);
+	    },
+    appendChild: function( newChild, refChild ) {
+        var rv = DOMElement.prototype.appendChild.apply(this, arguments);
+        var node = newChild;
+        var pn = this;
+        while(pn.parentNode) {
+            pn = pn.parentNode;
+        }
+        if(pn === node.ownerDocument) {
+           __exec_script_tags__(newChild);
+        }
+        return rv;
+    }
+});
+var __exec_script_tags__ = function(node) {
+    var $env =  __ownerDocument__(node)._parentWindow.$envx;
+    var doc = __ownerDocument__(node);
+    var type = ( node.type === null ) ? "text/javascript" : node.type;
+    // print("check exec",node,node.ownerDocument.in_inner_html);
+    // print(node,node.childNodes.length);
+    if(node.nodeName.toLowerCase() == 'script' && type == "text/javascript"){
+        // print("check",node,node.src,node.text,node.ownerDocument.in_inner_html,doc.parentWindow,node.executed);
+        if (node.ownerDocument.in_inner_html) {
+            //print("ignore",node);
+            node.executed = true;
+        } else if (doc.parentWindow &&
+                   !node.ownerDocument.in_inner_html &&
+                   !node.executed && (
+                       (node.src && !node.src.match(/^\s*$/)) ||
+                        (node.text && !node.text.match(/^\s*$/))
+                   ) ) {
+            node.executed = true;
+            //p.replaceEntities = true;
+            //print("exec",node);
+            var okay = $env.loadLocalScript(node, null);
+            // only fire event if we actually had something to load
+            if (node.src && node.src.length > 0){
+                var event = doc.createEvent();
+                event.initEvent( okay ? "load" : "error", false, false );
+                node.dispatchEvent( event, false );
+            }
+        }
+    }
+    for(var i=0; i < node.childNodes.length; i++) {
+        __exec_script_tags__(node.childNodes[i]);
+    }
+};
+var __recursivelyGatherText__ = function(aNode) {
+    var accumulateText = "";
+    var idx; var n;
+    for (idx=0;idx < aNode.childNodes.length;idx++){
+        n = aNode.childNodes.item(idx);
+        if(n.nodeType == DOMNode.TEXT_NODE)
+            accumulateText += n.data;
+        else
+            accumulateText += __recursivelyGatherText__(n);
+    }
+    return accumulateText;
+};
+var __eval__ = function(script,node){
+    if (script == "")
+        return undefined;
+    try {
+        var scope = node;
+        var __scopes__ = [];
+        var original = script;
+        if(scope) {
+            // script = "(function(){return eval(original)}).call(__scopes__[0])";
+            script = "return (function(){"+original+"}).call(__scopes__[0])";
+            while(scope) {
+                __scopes__.push(scope);
+                scope = scope.parentNode;
+                script = "with(__scopes__["+(__scopes__.length-1)+"] ){"+script+"};";
+            }
+        }
+        script = "function(original,__scopes__){"+script+"}";
+        // print("scripta",script);
+        // print("scriptb",original);
+        var original_script_window = $master.first_script_window;
+        if ( !$master.first_script_window ) {
+            // $master.first_script_window = window;
+        }
+        // FIX!!!
+        var $inner = node.ownerDocument._parentWindow["$inner"];
+        var result = $master.evaluate(script,$inner)(original,__scopes__);
+        // $master.first_script_window = original_script_window;
+        return result;
+    }catch(e){
+        $warn("Exception during on* event eval: "+e);
+        throw e;
+    }
+};
+var __updateCss2Props__ = function(elem, values){
+    if(elem.$css2props === null){
+        elem.$css2props = new CSS2Properties(elem);
+    }
+    __cssTextToStyles__(elem.$css2props, values);
+};
+var __registerEventAttrs__ = function(elm){
+    if(elm.hasAttribute('onclick')){
+        elm.addEventListener('click', elm.onclick );
+    }
+    if(elm.hasAttribute('ondblclick')){
+        elm.addEventListener('dblclick', elm.onclick );
+    }
+    if(elm.hasAttribute('onkeydown')){
+        elm.addEventListener('keydown', elm.onclick );
+    }
+    if(elm.hasAttribute('onkeypress')){
+        elm.addEventListener('keypress', elm.onclick );
+    }
+    if(elm.hasAttribute('onkeyup')){
+        elm.addEventListener('keyup', elm.onclick );
+    }
+    if(elm.hasAttribute('onmousedown')){
+        elm.addEventListener('mousedown', elm.onclick );
+    }
+    if(elm.hasAttribute('onmousemove')){
+        elm.addEventListener('mousemove', elm.onclick );
+    }
+    if(elm.hasAttribute('onmouseout')){
+        elm.addEventListener('mouseout', elm.onclick );
+    }
+    if(elm.hasAttribute('onmouseover')){
+        elm.addEventListener('mouseover', elm.onclick );
+    }
+    if(elm.hasAttribute('onmouseup')){
+        elm.addEventListener('mouseup', elm.onclick );
+    }
+    return elm;
+};
+// non-ECMA function, but no other way for click events to enter env.js
+var  __click__ = function(element){
+    var event = new Event({
+      target:element,
+      currentTarget:element
+    });
+    event.initEvent("click");
+    element.dispatchEvent(event);
+};
+var __submit__ = function(element){
+	var event = new Event({
+	  target:element,
+	  currentTarget:element
+	});
+	event.initEvent("submit");
+	element.dispatchEvent(event);
+};
+var __focus__ = function(element){
+	var event = new Event({
+	  target:element,
+	  currentTarget:element
+	});
+	event.initEvent("focus");
+	element.dispatchEvent(event);
+};
+var __blur__ = function(element){
+	var event = new Event({
+	  target:element,
+	  currentTarget:element
+	});
+	event.initEvent("blur");
+	element.dispatchEvent(event);
+};
+// $w.HTMLElement = HTMLElement;
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End:

data/src/html/fieldset.js ADDED Viewed

@@ -0,0 +1,19 @@
+$debug("Defining HTMLFieldSetElement");
+/*
+* HTMLFieldSetElement - DOM Level 2
+*/
+var HTMLFieldSetElement = function(ownerDocument) {
+    this.HTMLLegendElement = HTMLLegendElement;
+    this.HTMLLegendElement(ownerDocument);
+};
+HTMLFieldSetElement.prototype = new HTMLLegendElement;
+__extend__(HTMLFieldSetElement.prototype, {
+    get margin(){
+        return this.getAttribute('margin');
+    },
+    set margin(value){
+        this.setAttribute('margin',value);
+    }
+});
+// $w.HTMLFieldSetElement = HTMLFieldSetElement;

data/src/html/form.js ADDED Viewed

@@ -0,0 +1,484 @@
+$debug("Defining HTMLFormElement");
+/*
+* HTMLFormElement - DOM Level 2
+*/
+var HTMLFormElement = function(ownerDocument){
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLFormElement.prototype = new HTMLElement;
+__extend__(HTMLFormElement.prototype,{
+    get acceptCharset(){
+        return this.getAttribute('accept-charset');
+    },
+    set acceptCharset(acceptCharset){
+        this.setAttribute('accept-charset', acceptCharset);
+    },
+    get action(){
+        return this.getAttribute('action');
+    },
+    set action(action){
+        this.setAttribute('action', action);
+    },
+    get elements() {
+        return this.getElementsByTagName("*");
+    },
+    get enctype(){
+        return this.getAttribute('enctype');
+    },
+    set enctype(enctype){
+        this.setAttribute('enctype', enctype);
+    },
+    get length() {
+        return this.elements.length;
+    },
+    get method(){
+        return this.getAttribute('method');
+    },
+    set method(action){
+        this.setAttribute('method', action);
+    },
+	get name() {
+	    return this.getAttribute("name");
+    },
+	set name(val) {
+	    return this.setAttribute("name",val);
+    },
+	get target() {
+	    return this.getAttribute("target");
+    },
+	set target(val) {
+	    return this.setAttribute("target",val);
+    },
+	submit:function(){
+	    __submit__(this);
+    },
+	reset:function(){
+	    __reset__(this);
+    },
+    onsubmit:function(){
+        var v;
+        if ((v = __eval__(this.getAttribute('onsubmit')||'', this)) != false) {
+            // this.submit();
+        }
+        return v;
+    },
+    onreset:function(){
+        var v;
+        if ((v = __eval__(this.getAttribute('onreset')||'', this)) != false) {
+            this.reset();
+        }
+        return v;
+    }
+});
+// $w.HTMLFormElement	= HTMLFormElement;
+/**
+ * Form Submissions
+ *
+ * This code is borrow largely from jquery.params and jquery.form.js
+ *
+ * formToArray() gathers form element data into an array of objects that can
+ * be passed to any of the following ajax functions: $.get, $.post, or load.
+ * Each object in the array has both a 'name' and 'value' property.  An example of
+ * an array for a simple login form might be:
+ *
+ * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
+ *
+ * It is this array that is passed to pre-submit callback functions provided to the
+ * ajaxSubmit() and ajaxForm() methods.
+ *
+ * The semantic argument can be used to force form serialization in semantic order.
+ * This is normally true anyway, unless the form contains input elements of type='image'.
+ * If your form must be submitted with name/value pairs in semantic order and your form
+ * contains an input of type='image" then pass true for this arg, otherwise pass false
+ * (or nothing) to avoid the overhead for this logic.
+ *
+ *
+ * @name formToArray
+ * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
+ * @type Array<Object>
+ */
+var __formToArray__ = function(form, semantic, boundary) {
+    var array = [],
+        elements = semantic ? form.getElementsByTagName('*') : form.elements,
+        element,
+        i,j,imax, jmax,
+        name,
+        value;
+    if (!elements)
+        return array;
+    imax = elements.length;
+    for(i=0; i < imax; i++) {
+        element = elements[i];
+        name = element.name;
+        if (!name)
+            continue;
+        if (semantic && form.clk && element.type == "image") {
+            // handle image inputs on the fly when semantic == true
+            if(!element.disabled && form.clk == element) {
+                if (form.clk_x) {
+                    array.push({
+                        name: name+'.x',
+                        value: form.clk_x
+                    });
+                }
+                if (form.clk_y) {
+                    array.push({
+                        name: name+'.y',
+                        value: form.clk_y
+                    });
+                }
+            }
+            continue;
+        }
+        value = __fieldValue__(element, true);
+        if (value && value.constructor == Array) {
+            jmax = value.length;
+            for(j=0; j < jmax; j++){
+                // FIX: handle uploads with the same name
+                array.push({name: name, value: value[j]});
+            }
+        } else if (value !== null && typeof value != 'undefined'){
+            array.push({name: name, value: value});
+            if(element.type == "file") {
+                var v = array[array.length-1];
+                v.filename = element.value || null;
+            }
+        }
+    }
+    if (!semantic && form.clk) {
+        // input type=='image' are not found in elements array! handle them here
+        elements = form.getElementsByTagName("input");
+        imax = imax=elements.length;
+        for(i=0; i < imax; i++) {
+            element = elements[i];
+            name = element.name;
+            if(name && !element.disabled && element.type == "image" && form.clk == element)
+                if (form.clk_x)
+                    array.push({name: name+'.x', value: form.clk_x});
+                if (form.clk_y)
+                    array.push({name: name+'.y', value: form.clk_y});
+        }
+    }
+    return array;
+};
+/**
+ * Serializes form data into a 'submittable' string. This method will return a string
+ * in the format: name1=value1&amp;name2=value2
+ *
+ * The semantic argument can be used to force form serialization in semantic order.
+ * If your form must be submitted with name/value pairs in semantic order then pass
+ * true for this arg, otherwise pass false (or nothing) to avoid the overhead for
+ * this logic (which can be significant for very large forms).
+ *
+ *
+ * @name formSerialize
+ * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
+ * @type String
+ */
+var __formSerialize__ = function(form, semantic,boundary) {
+    //hand off to param for proper encoding
+    v = __param__(__formToArray__(form, semantic,boundary),boundary);
+    // print("v",v);
+    return v;
+};
+this.__formSerialize__ = __formSerialize__;
+/**
+ * Serializes all field elements inputs Array into a query string.
+ * This method will return a string in the format: name1=value1&amp;name2=value2
+ *
+ * The successful argument controls whether or not serialization is limited to
+ * 'successful' controls (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.
+ *
+ *
+ * @name fieldSerialize
+ * @param successful true if only successful controls should be serialized (default is true)
+ * @type String
+ */
+var __fieldSerialize__ = function(inputs, successful) {
+    var array = [],
+        input,
+        name,
+        value,
+        i,j, imax, jmax;
+    imax = inputs.length;
+    for(i=0; i<imax; i++){
+        input = inputs[i];
+        name = input.name;
+        if (!name)
+            return;
+        value = __fieldValue__(input, successful);
+        if (value && value.constructor == Array) {
+            jmax = value.length;
+            for (j=0; j < max; j++){
+                array.push({
+                    name: name,
+                    value: value[j]
+                });
+            }
+        }else if (value !== null && typeof value != 'undefined'){
+            array.push({
+                name: input.name,
+                value: value
+            });
+        }
+    };
+    //hand off  for proper encoding
+    return __param__(array);
+};
+/**
+ * Returns the value(s) of the element in the matched set.  For example, consider the following form:
+ *
+ *
+ * The successful argument controls whether or not the field element must be 'successful'
+ * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.  If this value is false the value(s)
+ * for each element is returned.
+ *
+ * Note: This method *always* returns an array.  If no valid value can be determined the
+ *       array will be empty, otherwise it will contain one or more values.
+ *
+ *
+ * @name fieldValue
+ * @param Boolean successful true if only the values for successful controls
+ *        should be returned (default is true)
+ * @type Array<String>
+ */
+var __fieldValues__ = function(inputs, successful) {
+    var i,
+        imax = inputs.length,
+        element,
+        values = [],
+        value;
+    for (i=0; i < imax; i++) {
+        element = inputs[i];
+        value = __fieldValue__(element, successful);
+        if (value === null || typeof value == 'undefined' ||
+            (value.constructor == Array && !value.length))
+            continue;
+        value.constructor == Array ?
+            Array.prototype.push(values, value) :
+            values.push(value);
+    }
+    return values;
+};
+/**
+ * Returns the value of the field element.
+ *
+ * The successful argument controls whether or not the field element must be 'successful'
+ * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.  If the given element is not
+ * successful and the successful arg is not false then the returned value will be null.
+ *
+ * Note: If the successful flag is true (default) but the element is not successful, the return will be null
+ * Note: The value returned for a successful select-multiple element will always be an array.
+ * Note: If the element has no value the return value will be undefined.
+ *
+ * @name fieldValue
+ * @param Element el The DOM element for which the value will be returned
+ * @param Boolean successful true if value returned must be for a successful controls (default is true)
+ * @type String or Array<String> or null or undefined
+ */
+var __fieldValue__ = function(element, successful) {
+    var name = element.name,
+        type = element.type,
+        tag = element.tagName.toLowerCase(),
+        index,
+        array,
+        options,
+        option,
+        one,
+        i, imax,
+        value;
+    if (typeof successful == 'undefined') successful = true;
+    // NOTE: changed to default to first selected: could do this when building the DOM?
+    // Probably, but a little unclear ...
+    if (successful && (!name || element.disabled || type == 'reset' || type == 'button' ||
+             (type == 'checkbox' || type == 'radio') &&  !element.checked ||
+             (type == 'submit' || type == 'image') &&
+             element.form && element.form.clk != element || (false && tag == 'select' &&
+             element.selectedIndex == -1)))
+            return null;
+    if (tag == 'select') {
+        index = element.selectedIndex;
+        // print("i",index);
+        if (index < 0)
+            // return null;
+            index = 0;
+        array = [];
+        options = element.options;
+        one = (type == 'select-one');
+        imax = (one ? index+1 : options.length);
+        i = (one ? index : 0);
+        for( i; i < imax; i++) {
+            option = options[i];
+            if (option && option.selected) {
+                value = option.value;
+                if (one)
+                    return value;
+                array.push(value);
+            }
+        }
+        if (array.length === 0) {
+            if (element.options[0]) {
+                array.push( element.options[0].value );
+            }
+        }
+        return array;
+    }
+    // print("**",tag,type,element.value,element.innerText);
+    if (type == "file") {
+        return Ruby.File.basename(element.value);
+    }
+    if (tag == "textarea") {
+        return element.innerText;
+    }
+    return element.value;
+};
+/**
+ * Clears the form data.  Takes the following actions on the form's input fields:
+ *  - input text fields will have their 'value' property set to the empty string
+ *  - select elements will have their 'selectedIndex' property set to -1
+ *  - checkbox and radio inputs will have their 'checked' property set to false
+ *  - inputs of type submit, button, reset, and hidden will *not* be effected
+ *  - button elements will *not* be effected
+ *
+ *
+ * @name clearForm
+ */
+var __clearForm__ = function(form) {
+    var i,
+        j, jmax,
+        elements,
+        resetable = ['input','select','textarea'];
+    for(i=0; i<resetable.lenth; i++){
+        elements = form.getElementsByTagName(resetable[i]);
+        jmax = elements.length;
+        for(j=0;j<jmax;j++){
+            __clearField__(elements[j]);
+        }
+    }
+};
+/**
+ * Clears the selected form element.  Takes the following actions on the element:
+ *  - input text fields will have their 'value' property set to the empty string
+ *  - select elements will have their 'selectedIndex' property set to -1
+ *  - checkbox and radio inputs will have their 'checked' property set to false
+ *  - inputs of type submit, button, reset, and hidden will *not* be effected
+ *  - button elements will *not* be effected
+ *
+ * @name clearFields
+ */
+var __clearField__ = function(element) {
+    var type = element.type,
+        tag = element.tagName.toLowerCase();
+    if (type == 'text' || type == 'password' || tag == 'textarea')
+        element.value = '';
+    else if (type == 'checkbox' || type == 'radio')
+        element.checked = false;
+    else if (tag == 'select')
+        element.selectedIndex = -1;
+};
+// Serialize an array of key/values into a query string
+var __param__= function( array, boundary ) {
+    var serialized = [];
+    if(boundary) {
+        for(i=0; i<array.length; i++){
+            if (array[i].filename === null) {
+                continue;
+            }
+            serialized.push( "--"+boundary + "\r\n" );
+            var fn = array[i].filename ? '; filename="'+array[i].value+'"' : "";
+            if (fn) {
+                var mime_type = "text/plain";
+                var transfer_encoding;
+                if (array[i].filename.match(/\.jpe?g$/)) {
+                    mime_type = "image/jpeg";
+                    transfer_encoding = "base64";
+                }
+                var content;
+                if (transfer_encoding === "base64") {
+                    Ruby.require("base64");
+                    content = Ruby.eval("lambda { |fn| Base64.encode64(File.read(fn)) }").call(array[i].filename);
+                } else {
+                    content = Ruby.File.read(array[i].filename);
+                }
+                // FIX: better mime types
+                array[i].value = [ "Content-Type: "+mime_type ];
+                if(transfer_encoding) {
+                    array[i].value.push("Content-Transfer-Encoding: "+transfer_encoding);
+                }
+                array[i].value.push("Content-Length: "+content.length);
+                array[i].value.push("");
+                array[i].value.push(content);
+                array[i].value = array[i].value.join("\r\n");
+            }
+            serialized.push('Content-Disposition: form-data; name="'+array[i].name+'"'+fn+'\r\n');
+            serialized.push(array[i].value);
+            serialized.push( "\r\n" );
+        }
+        serialized.push( "--"+boundary + "--\r\n" );
+        var v = serialized.join("");
+        // print("vvvv",v);
+        return v;
+    } else {
+        // Serialize the key/values
+        for(i=0; i<array.length; i++){
+            serialized[ serialized.length ] =
+                encodeURIComponent(array[i].name) + '=' +
+                encodeURIComponent(array[i].value);
+        }
+        // Return the resulting serialization
+        return serialized.join("&").replace(/%20/g, "+");
+    }
+};
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End: