adhearsion 0.7.6 → 0.7.7

data/apps/default/config/helpers/micromenus/javascripts/columnav.js

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2007, David A. Lindquist (stringify.com)
+ * Some Rights Reserved
+ *
+ * This code is licensed under the Creative Commons Attribution 2.5 License
+ * (http://creativecommons.org/licenses/by/2.5/). Please maintain the above
+ * license and copyright statements when using this code.
+ *
+ * $Id: columnav.js 481 2007-02-21 05:56:01Z david $
+ */
+YAHOO.namespace('extension');
+
+YAHOO.extension.ColumNav = function(id, cfg) {
+    this._init(id, cfg);
+};
+
+YAHOO.extension.ColumNav.prototype = {
+
+    DOM: YAHOO.util.Dom,
+    EVT: YAHOO.util.Event,
+    CON: YAHOO.util.Connect,
+
+    ERROR_MSG: 'data unavailable',
+
+    // PUBLIC API
+
+    reset: function() {
+        this.carousel.clear();
+        this._init(this.id, this.cfg);
+    },
+
+    // PRIVATE API
+
+    _init: function(id, cfg) {
+        this.id = id;
+        this.cfg = cfg; // make this a YAHOO.util.Config object?
+
+        this.source = cfg.source;
+        this.linkAction = cfg.linkAction || this._defaultLinkAction;
+        this.request = null;
+        this.counter = 1;
+        this.numScrolled = 0;
+        this.moving = false;
+        this.carousel = new YAHOO.extension.Carousel(id,
+                            {
+                                'animationCompleteHandler': this._animationCompleteHandler,
+                                'loadPrevHandler':          this._loadPrevHandler,
+                                'numVisible':               cfg.numVisible || 1,
+                                'prevElement':              cfg.prevElement || cfg.prevId,
+                                'scrollInc':                1
+                            });
+        this.carousel.cn = this;
+
+        var notOpera = (navigator.userAgent.match(/opera/i) == null);
+        var kl = new YAHOO.util.KeyListener(this.carousel.carouselElem,
+                                            { ctrl: notOpera, keys: [37, 38, 39, 40] },
+                                            { fn: this._handleKeypress,
+                                              scope: this,
+                                              correctScope: true });
+        kl.enable();
+
+        var source = this.source;
+        if (source && source.nodeType == 1)
+            this._addMenu(source);
+        else if (typeof source == 'string')
+            this._makeRequest(source);
+        else
+            this._handleFailure({});
+    },
+
+    _loadPrevHandler: function(type, args) {
+        this.cn._abortRequest();
+    },
+
+    _makeRequest: function(url) {
+        var callback = {
+            'success':  this._handleSuccess,
+            'failure':  this._handleFailure,
+            'scope':    this,
+            'timeout':  5000
+        };
+        this._abortRequest();
+        this.request = this.CON.asyncRequest('GET', url, callback);
+    },
+
+    _abortRequest: function() {
+        if (this.request && this.CON.isCallInProgress(this.request))
+            this.CON.abort(this.request);
+    },
+
+    _handleSuccess: function(o) {
+        this._addMenu(o.responseXML.documentElement);
+    },
+
+    _handleFailure: function(o) {
+        var list = document.createElement('ul');
+        var item = document.createElement('li');
+        var span = document.createElement('span');
+        span.className = 'columnav-error';
+        span.appendChild(document.createTextNode(this.ERROR_MSG));
+        item.appendChild(span);
+        list.appendChild(item);
+        this._addMenu(list);
+    },
+
+    _handleKeypress: function(type, args, o) {
+        var key = args[0];
+        var evt = args[1];
+        var target = this.EVT.getTarget(evt);
+        if (target.tagName != 'A') {
+            var links = this._getNodes(this.carousel.carouselList.lastChild,
+                                       this._links);
+            links[0].focus();
+            return;
+        }
+        switch (key) {
+        case 37: // left
+            var menu = target.parentNode.parentNode;
+            if (this._shouldScrollPrev(menu))
+                o.carousel.scrollPrev();
+            else {
+                var prevMenu = this._prevMenu(menu);
+                if (prevMenu)
+                    this._focus(prevMenu);
+            }
+            break;
+        case 38: // up
+            if (target.previousSibling)
+                target.previousSibling.focus();
+            break;
+        case 39: // right
+            this._next(evt);
+            break;
+        case 40: // down
+            if (target.nextSibling)
+                target.nextSibling.focus();
+            break;
+        }
+        this.EVT.stopEvent(evt);
+    },
+
+    _addMenu: function(node) {
+        var menu = this._createMenu(node);
+        this.carousel.addItem(this.counter++, menu);
+        if (this._shouldScrollNext()) {
+            this.carousel.scrollNext();
+            this.moving = true;
+        } else {
+            if (this.counter > 2)
+                this._focus(menu);
+        }
+    },
+
+    _shouldScrollNext: function() {
+        var numVisible = this.carousel.cfg.getProperty('numVisible');
+        return ((this.counter - 1) - this.numScrolled > numVisible);
+    },
+
+    _shouldScrollPrev: function(menu) {
+        var menus = this._getNodes(this.carousel.carouselList,
+                                   this._childElements);
+        var i = 0;
+        for ( ; i < menus.length; i++) {
+            if (menu == menus[i]) break;
+        }
+        return (i == this.numScrolled);
+    },
+
+    _prevMenu: function(menu) {
+        var prevLi = menu.previousSibling;
+        if (prevLi)
+            return prevLi.getElementsByTagName('div')[0];
+        return null;
+    },
+
+    _next: function(e) {
+        if (this.moving)
+            return;
+        var target = this.EVT.getTarget(e);
+        if (target.tagName == 'SPAN')
+            target = target.parentNode;
+        this._removeMenus(target);
+        var href = target.getAttribute('href');
+        var rel = target.getAttribute('rel');
+        var list = target.list;
+        if (href !== null)
+            this._highlight(target);
+        if (list)
+            this._addMenu(list);
+        else if (rel == 'ajax')
+            this._makeRequest(href);
+        else {
+            if (this.linkAction(e))
+                return true;
+        }
+        this.EVT.preventDefault(e);
+    },
+
+    _removeMenus: function(target) {
+        var li = target.parentNode.parentNode;
+        var list = this.carousel.carouselList;
+        while (li != list.lastChild) {
+            list.removeChild(list.lastChild);
+            this.counter--;
+        }
+    },
+
+    _highlight: function(target) {
+        var items = this._getNodes(target.parentNode, this._childElements);
+        for (var i = 0; i < items.length; i++)
+            this.DOM.removeClass(items[i], 'columnav-active');
+        this.DOM.addClass(target, 'columnav-active');
+    },
+
+    _focus: function(menu) {
+        var links = this._getNodes(menu, this._links);
+        for (var i = 0; i < links.length; i++) {
+            if (this.DOM.hasClass(links[i], 'columnav-active')) {
+                links[i].focus();
+                return;
+            }
+        }
+        links[0].focus();
+    },
+
+    _animationCompleteHandler: function(type, args) {
+        this.cn.moving = false;
+        if (args[0] == 'next') {
+            this.cn.numScrolled++;
+            this.cn._focus(this.carouselList.lastChild);
+        }
+        if (args[0] == 'prev') {
+            this.cn._removeLastMenu();
+            this.cn.numScrolled--;
+            if (this.cfg.getProperty('numVisible') == 1)
+                this.cn._focus(this.carouselList.lastChild);
+        }
+    },
+
+    _removeLastMenu: function() {
+        var list = this.carousel.carouselList;
+        list.removeChild(list.lastChild);
+        this.counter--;
+    },
+
+    _createMenu: function(node) {
+        var menu = document.createElement('div');
+        var items = this._getNodes(node, this._childElements);
+        for (var i = 0; i < items.length; i++) {
+            var ce = this._getNodes(items[i], this._childElements);
+            var link = ce[0], list = ce[1];
+            var text = link.firstChild.data;
+            var href = link.getAttribute('href');
+            var rel = link.getAttribute('rel');
+            var cls = link.getAttribute('class') || link.className;
+            var a = document.createElement('a');
+            var span = document.createElement('span');
+            span.appendChild(document.createTextNode(text));
+            a.appendChild(span);
+            a.setAttribute('href', href || 'javascript:void(0)');
+            a.setAttribute('rel', rel);
+            a.list = list;
+            if (cls)
+                this.DOM.addClass(a, cls);
+            if (list || rel == 'ajax')
+                this.DOM.addClass(a, 'columnav-has-menu');
+            this.EVT.addListener(a, 'click', this._next, this, true);
+            menu.appendChild(a);
+        }
+        return menu;
+    },
+
+    _defaultLinkAction: function() { return true; },
+
+    _getNodes: function(root, filter) {
+        var node = root;
+        var nodes = [];
+        var next;
+        var f = filter || function() { return true; }
+        while (node != null) {
+            if (node.hasChildNodes())
+                node = node.firstChild;
+            else if (node != root && null != (next = node.nextSibling))
+                node = next;
+            else {
+                next = null;
+                for ( ; node != root; node = node.parentNode) {
+                    next = node.nextSibling;
+                    if (next != null) break;
+                }
+                node = next;
+            }
+            if (node != null && f(node, root))
+                nodes.push(node);
+        }
+        return nodes;
+    },
+
+    _childElements: function(node, root) {
+        return (node.nodeType == 1 && node.parentNode == root);
+    },
+
+    _links: function(node) { return (node.tagName == 'A'); }
+};
+
+YAHOO.extension.ColumnNav = YAHOO.extension.ColumNav;

data/apps/default/config/helpers/micromenus/javascripts/connection.js

@@ -0,0 +1,965 @@
+/*
+Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 0.12.2
+*/
+/**
+ * The Connection Manager provides a simplified interface to the XMLHttpRequest
+ * object.  It handles cross-browser instantiantion of XMLHttpRequest, negotiates the
+ * interactive states and server response, returning the results to a pre-defined
+ * callback you create.
+ *
+ * @namespace YAHOO.util
+ * @module connection
+ * @requires yahoo
+ */
+
+/**
+ * The Connection Manager singleton provides methods for creating and managing
+ * asynchronous transactions.
+ *
+ * @class Connect
+ */
+YAHOO.util.Connect =
+{
+  /**
+   * @description Array of MSFT ActiveX ids for XMLHttpRequest.
+   * @property _msxml_progid
+   * @private
+   * @static
+   * @type array
+   */
+	_msxml_progid:[
+		'MSXML2.XMLHTTP.3.0',
+		'MSXML2.XMLHTTP',
+		'Microsoft.XMLHTTP'
+		],
+
+  /**
+   * @description Object literal of HTTP header(s)
+   * @property _http_header
+   * @private
+   * @static
+   * @type object
+   */
+	_http_header:{},
+
+  /**
+   * @description Determines if HTTP headers are set.
+   * @property _has_http_headers
+   * @private
+   * @static
+   * @type boolean
+   */
+	_has_http_headers:false,
+
+ /**
+  * @description Determines if a default header of
+  * Content-Type of 'application/x-www-form-urlencoded'
+  * will be added to any client HTTP headers sent for POST
+  * transactions.
+  * @property _use_default_post_header
+  * @private
+  * @static
+  * @type boolean
+  */
+    _use_default_post_header:true,
+
+ /**
+  * @description Determines if a default header of
+  * Content-Type of 'application/x-www-form-urlencoded'
+  * will be added to any client HTTP headers sent for POST
+  * transactions.
+  * @property _default_post_header
+  * @private
+  * @static
+  * @type boolean
+  */
+    _default_post_header:'application/x-www-form-urlencoded',
+
+ /**
+  * @description Property modified by setForm() to determine if the data
+  * should be submitted as an HTML form.
+  * @property _isFormSubmit
+  * @private
+  * @static
+  * @type boolean
+  */
+    _isFormSubmit:false,
+
+ /**
+  * @description Property modified by setForm() to determine if a file(s)
+  * upload is expected.
+  * @property _isFileUpload
+  * @private
+  * @static
+  * @type boolean
+  */
+    _isFileUpload:false,
+
+ /**
+  * @description Property modified by setForm() to set a reference to the HTML
+  * form node if the desired action is file upload.
+  * @property _formNode
+  * @private
+  * @static
+  * @type object
+  */
+    _formNode:null,
+
+ /**
+  * @description Property modified by setForm() to set the HTML form data
+  * for each transaction.
+  * @property _sFormData
+  * @private
+  * @static
+  * @type string
+  */
+    _sFormData:null,
+
+ /**
+  * @description Collection of polling references to the polling mechanism in handleReadyState.
+  * @property _poll
+  * @private
+  * @static
+  * @type object
+  */
+    _poll:{},
+
+ /**
+  * @description Queue of timeout values for each transaction callback with a defined timeout value.
+  * @property _timeOut
+  * @private
+  * @static
+  * @type object
+  */
+    _timeOut:{},
+
+  /**
+   * @description The polling frequency, in milliseconds, for HandleReadyState.
+   * when attempting to determine a transaction's XHR readyState.
+   * The default is 50 milliseconds.
+   * @property _polling_interval
+   * @private
+   * @static
+   * @type int
+   */
+     _polling_interval:50,
+
+  /**
+   * @description A transaction counter that increments the transaction id for each transaction.
+   * @property _transaction_id
+   * @private
+   * @static
+   * @type int
+   */
+     _transaction_id:0,
+
+  /**
+   * @description Member to add an ActiveX id to the existing xml_progid array.
+   * In the event(unlikely) a new ActiveX id is introduced, it can be added
+   * without internal code modifications.
+   * @method setProgId
+   * @public
+   * @static
+   * @param {string} id The ActiveX id to be added to initialize the XHR object.
+   * @return void
+   */
+	setProgId:function(id)
+	{
+		this._msxml_progid.unshift(id);
+	},
+
+  /**
+   * @description Member to enable or disable the default POST header.
+   * @method setDefaultPostHeader
+   * @public
+   * @static
+   * @param {boolean} b Set and use default header - true or false .
+   * @return void
+   */
+	setDefaultPostHeader:function(b)
+	{
+		this._use_default_post_header = b;
+	},
+
+  /**
+   * @description Member to modify the default polling interval.
+   * @method setPollingInterval
+   * @public
+   * @static
+   * @param {int} i The polling interval in milliseconds.
+   * @return void
+   */
+	setPollingInterval:function(i)
+	{
+		if(typeof i == 'number' && isFinite(i)){
+			this._polling_interval = i;
+		}
+	},
+
+  /**
+   * @description Instantiates a XMLHttpRequest object and returns an object with two properties:
+   * the XMLHttpRequest instance and the transaction id.
+   * @method createXhrObject
+   * @private
+   * @static
+   * @param {int} transactionId Property containing the transaction id for this transaction.
+   * @return object
+   */
+	createXhrObject:function(transactionId)
+	{
+		var obj,http;
+		try
+		{
+			// Instantiates XMLHttpRequest in non-IE browsers and assigns to http.
+			http = new XMLHttpRequest();
+			//  Object literal with http and tId properties
+			obj = { conn:http, tId:transactionId };
+		}
+		catch(e)
+		{
+			for(var i=0; i<this._msxml_progid.length; ++i){
+				try
+				{
+					// Instantiates XMLHttpRequest for IE and assign to http.
+					http = new ActiveXObject(this._msxml_progid[i]);
+					//  Object literal with conn and tId properties
+					obj = { conn:http, tId:transactionId };
+					break;
+				}
+				catch(e){}
+			}
+		}
+		finally
+		{
+			return obj;
+		}
+	},
+
+  /**
+   * @description This method is called by asyncRequest to create a
+   * valid connection object for the transaction.  It also passes a
+   * transaction id and increments the transaction id counter.
+   * @method getConnectionObject
+   * @private
+   * @static
+   * @return {object}
+   */
+	getConnectionObject:function()
+	{
+		var o;
+		var tId = this._transaction_id;
+
+		try
+		{
+			o = this.createXhrObject(tId);
+			if(o){
+				this._transaction_id++;
+			}
+		}
+		catch(e){}
+		finally
+		{
+			return o;
+		}
+	},
+
+  /**
+   * @description Method for initiating an asynchronous request via the XHR object.
+   * @method asyncRequest
+   * @public
+   * @static
+   * @param {string} method HTTP transaction method
+   * @param {string} uri Fully qualified path of resource
+   * @param {callback} callback User-defined callback function or object
+   * @param {string} postData POST body
+   * @return {object} Returns the connection object
+   */
+	asyncRequest:function(method, uri, callback, postData)
+	{
+		var o = this.getConnectionObject();
+
+		if(!o){
+			return null;
+		}
+		else{
+			if(this._isFormSubmit){
+				if(this._isFileUpload){
+					this.uploadFile(o.tId, callback, uri, postData);
+					this.releaseObject(o);
+
+					return;
+				}
+
+				//If the specified HTTP method is GET, setForm() will return an
+				//encoded string that is concatenated to the uri to
+				//create a querystring.
+				if(method == 'GET'){
+					if(this._sFormData.length != 0){
+						// If the URI already contains a querystring, append an ampersand
+						// and then concatenate _sFormData to the URI.
+						uri += ((uri.indexOf('?') == -1)?'?':'&') + this._sFormData;
+					}
+					else{
+						uri += "?" + this._sFormData;
+					}
+				}
+				else if(method == 'POST'){
+					//If POST data exist in addition to the HTML form data,
+					//it will be concatenated to the form data.
+					postData = postData?this._sFormData + "&" + postData:this._sFormData;
+				}
+			}
+
+			o.conn.open(method, uri, true);
+
+			if(this._isFormSubmit || (postData && this._use_default_post_header)){
+				this.initHeader('Content-Type', this._default_post_header);
+				if(this._isFormSubmit){
+					this.resetFormState();
+				}
+			}
+
+			if(this._has_http_headers){
+				this.setHeader(o);
+			}
+
+			this.handleReadyState(o, callback);
+			o.conn.send(postData || null);
+
+			return o;
+		}
+	},
+
+  /**
+   * @description This method serves as a timer that polls the XHR object's readyState
+   * property during a transaction, instead of binding a callback to the
+   * onreadystatechange event.  Upon readyState 4, handleTransactionResponse
+   * will process the response, and the timer will be cleared.
+   * @method handleReadyState
+   * @private
+   * @static
+   * @param {object} o The connection object
+   * @param {callback} callback The user-defined callback object
+   * @return {void}
+   */
+    handleReadyState:function(o, callback)
+    {
+		var oConn = this;
+
+		if(callback && callback.timeout){
+			this._timeOut[o.tId] = window.setTimeout(function(){ oConn.abort(o, callback, true); }, callback.timeout);
+		}
+
+		this._poll[o.tId] = window.setInterval(
+			function(){
+				if(o.conn && o.conn.readyState == 4){
+					window.clearInterval(oConn._poll[o.tId]);
+					delete oConn._poll[o.tId];
+
+					if(callback && callback.timeout){
+						delete oConn._timeOut[o.tId];
+					}
+
+					oConn.handleTransactionResponse(o, callback);
+				}
+			}
+		,this._polling_interval);
+    },
+
+  /**
+   * @description This method attempts to interpret the server response and
+   * determine whether the transaction was successful, or if an error or
+   * exception was encountered.
+   * @method handleTransactionResponse
+   * @private
+   * @static
+   * @param {object} o The connection object
+   * @param {object} callback The sser-defined callback object
+   * @param {boolean} isAbort Determines if the transaction was aborted.
+   * @return {void}
+   */
+    handleTransactionResponse:function(o, callback, isAbort)
+    {
+		// If no valid callback is provided, then do not process any callback handling.
+		if(!callback){
+			this.releaseObject(o);
+			return;
+		}
+
+		var httpStatus, responseObject;
+
+		try
+		{
+			if(o.conn.status !== undefined && o.conn.status != 0){
+				httpStatus = o.conn.status;
+			}
+			else{
+				httpStatus = 13030;
+			}
+		}
+		catch(e){
+			// 13030 is the custom code to indicate the condition -- in Mozilla/FF --
+			// when the o object's status and statusText properties are
+			// unavailable, and a query attempt throws an exception.
+			httpStatus = 13030;
+		}
+
+		if(httpStatus >= 200 && httpStatus < 300){
+			try
+			{
+				responseObject = this.createResponseObject(o, callback.argument);
+				if(callback.success){
+					if(!callback.scope){
+						callback.success(responseObject);
+					}
+					else{
+						// If a scope property is defined, the callback will be fired from
+						// the context of the object.
+						callback.success.apply(callback.scope, [responseObject]);
+					}
+				}
+			}
+			catch(e){}
+		}
+		else{
+			try
+			{
+				switch(httpStatus){
+					// The following cases are wininet.dll error codes that may be encountered.
+					case 12002: // Server timeout
+					case 12029: // 12029 to 12031 correspond to dropped connections.
+					case 12030:
+					case 12031:
+					case 12152: // Connection closed by server.
+					case 13030: // See above comments for variable status.
+						responseObject = this.createExceptionObject(o.tId, callback.argument, (isAbort?isAbort:false));
+						if(callback.failure){
+							if(!callback.scope){
+								callback.failure(responseObject);
+							}
+							else{
+								callback.failure.apply(callback.scope, [responseObject]);
+							}
+						}
+						break;
+					default:
+						responseObject = this.createResponseObject(o, callback.argument);
+						if(callback.failure){
+							if(!callback.scope){
+								callback.failure(responseObject);
+							}
+							else{
+								callback.failure.apply(callback.scope, [responseObject]);
+							}
+						}
+				}
+			}
+			catch(e){}
+		}
+
+		this.releaseObject(o);
+		responseObject = null;
+    },
+
+  /**
+   * @description This method evaluates the server response, creates and returns the results via
+   * its properties.  Success and failure cases will differ in the response
+   * object's property values.
+   * @method createResponseObject
+   * @private
+   * @static
+   * @param {object} o The connection object
+   * @param {callbackArg} callbackArg The user-defined argument or arguments to be passed to the callback
+   * @return {object}
+   */
+    createResponseObject:function(o, callbackArg)
+    {
+		var obj = {};
+		var headerObj = {};
+
+		try
+		{
+			var headerStr = o.conn.getAllResponseHeaders();
+			var header = headerStr.split('\n');
+			for(var i=0; i<header.length; i++){
+				var delimitPos = header[i].indexOf(':');
+				if(delimitPos != -1){
+					headerObj[header[i].substring(0,delimitPos)] = header[i].substring(delimitPos+2);
+				}
+			}
+		}
+		catch(e){}
+
+		obj.tId = o.tId;
+		obj.status = o.conn.status;
+		obj.statusText = o.conn.statusText;
+		obj.getResponseHeader = headerObj;
+		obj.getAllResponseHeaders = headerStr;
+		obj.responseText = o.conn.responseText;
+		obj.responseXML = o.conn.responseXML;
+
+		if(typeof callbackArg !== undefined){
+			obj.argument = callbackArg;
+		}
+
+		return obj;
+    },
+
+  /**
+   * @description If a transaction cannot be completed due to dropped or closed connections,
+   * there may be not be enough information to build a full response object.
+   * The failure callback will be fired and this specific condition can be identified
+   * by a status property value of 0.
+   *
+   * If an abort was successful, the status property will report a value of -1.
+   *
+   * @method createExceptionObject
+   * @private
+   * @static
+   * @param {int} tId The Transaction Id
+   * @param {callbackArg} callbackArg The user-defined argument or arguments to be passed to the callback
+   * @param {boolean} isAbort Determines if the exception case is caused by a transaction abort
+   * @return {object}
+   */
+    createExceptionObject:function(tId, callbackArg, isAbort)
+    {
+		var COMM_CODE = 0;
+		var COMM_ERROR = 'communication failure';
+		var ABORT_CODE = -1;
+		var ABORT_ERROR = 'transaction aborted';
+
+		var obj = {};
+
+		obj.tId = tId;
+		if(isAbort){
+			obj.status = ABORT_CODE;
+			obj.statusText = ABORT_ERROR;
+		}
+		else{
+			obj.status = COMM_CODE;
+			obj.statusText = COMM_ERROR;
+		}
+
+		if(callbackArg){
+			obj.argument = callbackArg;
+		}
+
+		return obj;
+    },
+
+  /**
+   * @description Public method that stores the custom HTTP headers for each transaction.
+   * @method initHeader
+   * @public
+   * @static
+   * @param {string} label The HTTP header label
+   * @param {string} value The HTTP header value
+   * @return {void}
+   */
+	initHeader:function(label,value)
+	{
+		if(this._http_header[label] === undefined){
+			this._http_header[label] = value;
+		}
+		else{
+			// Concatenate multiple values, comma-delimited,
+			// for the same header label,
+			this._http_header[label] =  value + "," + this._http_header[label];
+		}
+
+		this._has_http_headers = true;
+	},
+
+  /**
+   * @description Accessor that sets the HTTP headers for each transaction.
+   * @method setHeader
+   * @private
+   * @static
+   * @param {object} o The connection object for the transaction.
+   * @return {void}
+   */
+	setHeader:function(o)
+	{
+		for(var prop in this._http_header){
+			if(this._http_header.hasOwnProperty(prop)){
+				o.conn.setRequestHeader(prop, this._http_header[prop]);
+			}
+		}
+		delete this._http_header;
+
+		this._http_header = {};
+		this._has_http_headers = false;
+	},
+
+  /**
+   * @description This method assembles the form label and value pairs and
+   * constructs an encoded string.
+   * asyncRequest() will automatically initialize the
+   * transaction with a HTTP header Content-Type of
+   * application/x-www-form-urlencoded.
+   * @method setForm
+   * @public
+   * @static
+   * @param {string || object} form id or name attribute, or form object.
+   * @param {string} optional boolean to indicate SSL environment.
+   * @param {string || boolean} optional qualified path of iframe resource for SSL in IE.
+   * @return {string} string of the HTML form field name and value pairs..
+   */
+	setForm:function(formId, isUpload, secureUri)
+	{
+		this.resetFormState();
+		var oForm;
+		if(typeof formId == 'string'){
+			// Determine if the argument is a form id or a form name.
+			// Note form name usage is deprecated but supported
+			// here for legacy reasons.
+			oForm = (document.getElementById(formId) || document.forms[formId]);
+		}
+		else if(typeof formId == 'object'){
+			// Treat argument as an HTML form object.
+			oForm = formId;
+		}
+		else{
+			return;
+		}
+
+		// If the isUpload argument is true, setForm will call createFrame to initialize
+		// an iframe as the form target.
+		//
+		// The argument secureURI is also required by IE in SSL environments
+		// where the secureURI string is a fully qualified HTTP path, used to set the source
+		// of the iframe, to a stub resource in the same domain.
+		if(isUpload){
+
+			// Create iframe in preparation for file upload.
+			this.createFrame(secureUri?secureUri:null);
+
+			// Set form reference and file upload properties to true.
+			this._isFormSubmit = true;
+			this._isFileUpload = true;
+			this._formNode = oForm;
+
+			return;
+		}
+
+		var oElement, oName, oValue, oDisabled;
+		var hasSubmit = false;
+
+		// Iterate over the form elements collection to construct the
+		// label-value pairs.
+		for (var i=0; i<oForm.elements.length; i++){
+			oElement = oForm.elements[i];
+			oDisabled = oForm.elements[i].disabled;
+			oName = oForm.elements[i].name;
+			oValue = oForm.elements[i].value;
+
+			// Do not submit fields that are disabled or
+			// do not have a name attribute value.
+			if(!oDisabled && oName)
+			{
+				switch (oElement.type)
+				{
+					case 'select-one':
+					case 'select-multiple':
+						for(var j=0; j<oElement.options.length; j++){
+							if(oElement.options[j].selected){
+								if(window.ActiveXObject){
+									this._sFormData += encodeURIComponent(oName) + '=' + encodeURIComponent(oElement.options[j].attributes['value'].specified?oElement.options[j].value:oElement.options[j].text) + '&';
+								}
+								else{
+									this._sFormData += encodeURIComponent(oName) + '=' + encodeURIComponent(oElement.options[j].hasAttribute('value')?oElement.options[j].value:oElement.options[j].text) + '&';
+								}
+
+							}
+						}
+						break;
+					case 'radio':
+					case 'checkbox':
+						if(oElement.checked){
+							this._sFormData += encodeURIComponent(oName) + '=' + encodeURIComponent(oValue) + '&';
+						}
+						break;
+					case 'file':
+						// stub case as XMLHttpRequest will only send the file path as a string.
+					case undefined:
+						// stub case for fieldset element which returns undefined.
+					case 'reset':
+						// stub case for input type reset button.
+					case 'button':
+						// stub case for input type button elements.
+						break;
+					case 'submit':
+						if(hasSubmit == false){
+							this._sFormData += encodeURIComponent(oName) + '=' + encodeURIComponent(oValue) + '&';
+							hasSubmit = true;
+						}
+						break;
+					default:
+						this._sFormData += encodeURIComponent(oName) + '=' + encodeURIComponent(oValue) + '&';
+						break;
+				}
+			}
+		}
+
+		this._isFormSubmit = true;
+		this._sFormData = this._sFormData.substr(0, this._sFormData.length - 1);
+
+		return this._sFormData;
+	},
+
+  /**
+   * @description Resets HTML form properties when an HTML form or HTML form
+   * with file upload transaction is sent.
+   * @method resetFormState
+   * @private
+   * @static
+   * @return {void}
+   */
+	resetFormState:function(){
+		this._isFormSubmit = false;
+		this._isFileUpload = false;
+		this._formNode = null;
+		this._sFormData = "";
+	},
+
+  /**
+   * @description Creates an iframe to be used for form file uploads.  It is remove from the
+   * document upon completion of the upload transaction.
+   * @method createFrame
+   * @private
+   * @static
+   * @param {string} secureUri Optional qualified path of iframe resource for SSL in IE.
+   * @return {void}
+   */
+	createFrame:function(secureUri){
+
+		// IE does not allow the setting of id and name attributes as object
+		// properties via createElement().  A different iframe creation
+		// pattern is required for IE.
+		var frameId = 'yuiIO' + this._transaction_id;
+		if(window.ActiveXObject){
+			var io = document.createElement('<iframe id="' + frameId + '" name="' + frameId + '" />');
+
+			// IE will throw a security exception in an SSL environment if the
+			// iframe source is undefined.
+			if(typeof secureUri == 'boolean'){
+				io.src = 'javascript:false';
+			}
+			else if(typeof secureURI == 'string'){
+				// Deprecated
+				io.src = secureUri;
+			}
+		}
+		else{
+			var io = document.createElement('iframe');
+			io.id = frameId;
+			io.name = frameId;
+		}
+
+		io.style.position = 'absolute';
+		io.style.top = '-1000px';
+		io.style.left = '-1000px';
+
+		document.body.appendChild(io);
+	},
+
+  /**
+   * @description Parses the POST data and creates hidden form elements
+   * for each key-value, and appends them to the HTML form object.
+   * @method appendPostData
+   * @private
+   * @static
+   * @param {string} postData The HTTP POST data
+   * @return {array} formElements Collection of hidden fields.
+   */
+	appendPostData:function(postData)
+	{
+		var formElements = [];
+		var postMessage = postData.split('&');
+		for(var i=0; i < postMessage.length; i++){
+			var delimitPos = postMessage[i].indexOf('=');
+			if(delimitPos != -1){
+				formElements[i] = document.createElement('input');
+				formElements[i].type = 'hidden';
+				formElements[i].name = postMessage[i].substring(0,delimitPos);
+				formElements[i].value = postMessage[i].substring(delimitPos+1);
+				this._formNode.appendChild(formElements[i]);
+			}
+		}
+
+		return formElements;
+	},
+
+  /**
+   * @description Uploads HTML form, including files/attachments, to the
+   * iframe created in createFrame.
+   * @method uploadFile
+   * @private
+   * @static
+   * @param {int} id The transaction id.
+   * @param {object} callback - User-defined callback object.
+   * @param {string} uri Fully qualified path of resource.
+   * @return {void}
+   */
+	uploadFile:function(id, callback, uri, postData){
+
+		// Each iframe has an id prefix of "yuiIO" followed
+		// by the unique transaction id.
+		var frameId = 'yuiIO' + id;
+		var io = document.getElementById(frameId);
+
+		// Initialize the HTML form properties in case they are
+		// not defined in the HTML form.
+		this._formNode.action = uri;
+		this._formNode.method = 'POST';
+		this._formNode.target = frameId;
+
+		if(this._formNode.encoding){
+			// IE does not respect property enctype for HTML forms.
+			// Instead use property encoding.
+			this._formNode.encoding = 'multipart/form-data';
+		}
+		else{
+			this._formNode.enctype = 'multipart/form-data';
+		}
+
+		if(postData){
+			var oElements = this.appendPostData(postData);
+		}
+
+		this._formNode.submit();
+
+		if(oElements && oElements.length > 0){
+			try
+			{
+				for(var i=0; i < oElements.length; i++){
+					this._formNode.removeChild(oElements[i]);
+				}
+			}
+			catch(e){}
+		}
+
+		// Reset HTML form status properties.
+		this.resetFormState();
+
+		// Create the upload callback handler that fires when the iframe
+		// receives the load event.  Subsequently, the event handler is detached
+		// and the iframe removed from the document.
+
+		var uploadCallback = function()
+		{
+			var obj = {};
+			obj.tId = id;
+			obj.argument = callback.argument;
+
+			try
+			{
+				obj.responseText = io.contentWindow.document.body?io.contentWindow.document.body.innerHTML:null;
+				obj.responseXML = io.contentWindow.document.XMLDocument?io.contentWindow.document.XMLDocument:io.contentWindow.document;
+			}
+			catch(e){}
+
+			if(callback.upload){
+				if(!callback.scope){
+					callback.upload(obj);
+				}
+				else{
+					callback.upload.apply(callback.scope, [obj]);
+				}
+			}
+
+			if(YAHOO.util.Event){
+				YAHOO.util.Event.removeListener(io, "load", uploadCallback);
+			}
+			else if(window.detachEvent){
+				io.detachEvent('onload', uploadCallback);
+			}
+			else{
+				io.removeEventListener('load', uploadCallback, false);
+			}
+			setTimeout(function(){ document.body.removeChild(io); }, 100);
+		};
+
+
+		// Bind the onload handler to the iframe to detect the file upload response.
+		if(YAHOO.util.Event){
+			YAHOO.util.Event.addListener(io, "load", uploadCallback);
+		}
+		else if(window.attachEvent){
+			io.attachEvent('onload', uploadCallback);
+		}
+		else{
+			io.addEventListener('load', uploadCallback, false);
+		}
+	},
+
+  /**
+   * @description Method to terminate a transaction, if it has not reached readyState 4.
+   * @method abort
+   * @public
+   * @static
+   * @param {object} o The connection object returned by asyncRequest.
+   * @param {object} callback  User-defined callback object.
+   * @param {string} isTimeout boolean to indicate if abort was a timeout.
+   * @return {boolean}
+   */
+	abort:function(o, callback, isTimeout)
+	{
+		if(this.isCallInProgress(o)){
+			o.conn.abort();
+			window.clearInterval(this._poll[o.tId]);
+			delete this._poll[o.tId];
+			if(isTimeout){
+				delete this._timeOut[o.tId];
+			}
+
+			this.handleTransactionResponse(o, callback, true);
+
+			return true;
+		}
+		else{
+			return false;
+		}
+	},
+
+  /**
+   * Public method to check if the transaction is still being processed.
+   *
+   * @method isCallInProgress
+   * @public
+   * @static
+   * @param {object} o The connection object returned by asyncRequest
+   * @return {boolean}
+   */
+	isCallInProgress:function(o)
+	{
+		// if the XHR object assigned to the transaction has not been dereferenced,
+		// then check its readyState status.  Otherwise, return false.
+		if(o.conn){
+			return o.conn.readyState != 4 && o.conn.readyState != 0;
+		}
+		else{
+			//The XHR object has been destroyed.
+			return false;
+		}
+	},
+
+  /**
+   * @description Dereference the XHR instance and the connection object after the transaction is completed.
+   * @method releaseObject
+   * @private
+   * @static
+   * @param {object} o The connection object
+   * @return {void}
+   */
+	releaseObject:function(o)
+	{
+		//dereference the XHR instance.
+		o.conn = null;
+		//dereference the connection object.
+		o = null;
+	}
+};