/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* This is the configuration for the main UI Client Event Capture JavaScript.
* It contains versioning information and the the flag thant turns 
* the JavaScript into a true SDK.  
*
* @version 2009.06.09.1
*                                                                   
*/
if(typeof TeaLeaf == "undefined"){
	var TeaLeaf = {};
	TeaLeaf.tlStartLoad = new Date();

    if(typeof TeaLeaf.Configuration == "undefined"){
	    TeaLeaf.Configuration = {
	        "tlinit" : false,
		    "tlversion" : "2009.06.09.1",
		    "tlSDK" : false
	    };
    }
}

/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* Configuration file for TeaLeafEvent.js   
*
* @version  2009.06.09.1
*                                                                   
*/

if(typeof TeaLeaf.Event == "undefined"){
	//	Constructor for the Event
    TeaLeaf.Event = function(type, subtype, source) {    
	    this.date = new Date();
	    if( subtype ) {
		    this.EventType    = type;
		    this.EventSubType = subtype;
		    if( source ) {
			    this.EventSource = source;
		    }
		    else{
		        //default is empty string
		        this.EventSource ="";
		    }
	    }
	    else {
		    this.EventType    = "CUSTOM";
		    this.EventSubType = type;
	    }
    }
    
   if(typeof TeaLeaf.Event.Configuration == "undefined"){  
        TeaLeaf.Event.Configuration = {
            "tlinit"                    : false,
            "tlqueueevents"             : true,
            "tlqueueeventstimer"        : 30000,
            "tlqueueeventsmaxsz"        : 8192,
            "tlshowexceptions"          : false,
            "tlurl"                     : "/js/TeaLeafTarget.asp",
            "tlsecureurl"               : "/js/TeaLeafTarget.asp",
            "tlpageidcookie"            : "TLTHID",
            "tleventcount"              : 0, 
            "tlpageid"                  : "", 
            "tlinitflag"                : false,
            "tlbeforeunloadflag"        : false,
            "tlusetopqueue"             : false,
            "tllastdwelltime"           : "",
            "tlidoflastvisitedcontrol"  : "",
            "tleventunloadflag"         : true,
            "tleventbeforeunloadflag"   : true,
            "tlcatcherrors"             : true,
            "tlignoresendfailure"       : true,
            "tlasync"                   : true,
            "tlvisitorder"              : "",

            tlResolution:[
                {"width": 799,       "height": 599,     "type": 0,  "displayText": "small"},
                {"width": 800,       "height": 600,     "type": 1,  "displayText": "800x600"},
                {"width": 1024,      "height": 760,     "type": 2,  "displayText": "1024x760"},
                {"width": 1280,      "height": 1024,    "type": 3,  "displayText": "1280x1024"},
                {"width": 1000000,   "height": 1000000, "type": 4,  "displayText": "large"}
            ],		             
            //This is the list of HTTP headers that are static and are
		    tlHTTPRequestHeadersSet:[
		        {"tlreqhttpheadername": "Content-Type",                     "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetContentType()"},
			    {"tlreqhttpheadername": "X-TeaLeaf",                        "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetTeaLeafXEvent()"},
			    {"tlreqhttpheadername": "X-TeaLeafType",                    "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlEventType()"},
			    {"tlreqhttpheadername": "X-TeaLeafSubType",                 "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlEventSubType()"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Url",               "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetUrlPath()"},
                {"tlreqhttpheadername": "X-TeaLeaf-UIEventCapture-Version", "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetJSVersion()"}
		    ],   
		    //This is the list of HTTP headers that have the eval value at the time of POST
		    tlHTTPRequestHeadersEvalInit:[
			    {"tlreqhttpheadername": "X-TeaLeaf-Screen-Res",         "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlResolutionType(screen.width ,screen.height)"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Browser-Res",        "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlResolutionTypeBrowser()"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Render",        "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetRenderTime()"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Objects",       "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetElementCount(\"object\")"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Img-Fail",      "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlBadImageCount()"}
		    ],  
		    tlHTTPRequestHeadersEvalBeforeUnload:[
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Cui-Events",    "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetEventCount()"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Cui-Bytes",     "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetSendStringBytes(sendStr)"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Dwell",         "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetDwellTime()"},
			    {"tlreqhttpheadername": "X-TeaLeaf-Page-Last-Field",    "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetLastVisitedElementID()"},   
			    {"tlreqhttpheadername": "X-TeaLeaf-Visit-Order",        "tlsethttpheader": true,    "tlreqhttpheadervalue": "TeaLeaf.Event.tlGetVisitOrder()"}   
		    ]   
        };  
    }   
}

/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* This is the configuration for TeaLeafEnv.js  
*
* @version 2009.06.09.1
*                                                                   
*/
if(typeof TeaLeaf.Env == "undefined"){	
	TeaLeaf.Env = {};

    if(typeof TeaLeaf.Env.Configuration == "undefined"){
        TeaLeaf.Env.Configuration = {
            "tlinit" : false,
            "tlinitpost" : true,
            
            tlPlugins : [
		        {"tlIEplugin": "ShockwaveFlash.ShockwaveFlash.1",         "tlpluginname": "Shockwave Flash",      "tlversion":"1.0",    "tlenable": false},    
		        {"tlIEplugin": "MediaPlayer.MediaPlayer.1",               "tlpluginname": "Windows Media Player", "tlversion":"",    "tlenable": false},
		        {"tlIEplugin": "PDF.PdfCtrl.1",                           "tlpluginname": "Adobe Acrobat",        "tlversion":"",     "tlenable": false},
		        {"tlIEplugin": "QuickTimeCheckObject.QuickTimeCheck.1",   "tlpluginname": "QuickTime",            "tlversion":"",     "tlenable": false}
			]
        };
    }
}
/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* This is the configuration file for capturing Client Events that 
* happen on the rendered DOM. It proviedes the capabilty to block fields
* and turn off an on events on the Window and Document object. 
*
* @version 2009.06.09.1
*                                                                   
*/
if(typeof TeaLeaf.Client == "undefined"){
    TeaLeaf.Client = {};

    if(typeof TeaLeaf.Client.Configuration == "undefined"){
	    TeaLeaf.Client.Configuration = {
	        "tlinit" : false,
		    "tlpassword"         : 1,		// 1 no capture, 2 don't send value
		    "tlsendfocus"        : false,
		    "tlsendblur"         : true,
		    "tlunloadflag"       : true,
		    "tlactiontype"       : "No Submit",
		    "tlbeforeunloadflag" : true,
		    "tlcontrolsattached" : false,
		    "tlassignTLID"       : false,   
		    "tlscanupdate"       : 0,
		    "tlIEhref"           : false,

		    //	tlScheduledScan controls whether or not to periodically scan the DOM
		    //	for changes (and tag the appropriate nodes) at the interval defined by
		    //	tlscanupdate
		    tlScheduledScan : true,

		    //  tlExcludeTags controls whether to explicitly exclude or include the
		    //  tags listed in tlNodeTags when attaching to descendent elements using
		    //  TeaLeaf.Client.tlProcessNode(). See TeaLeaf.Client.tlTagNameAllowed()
		    tlExcludeTags : true,

		    //	If events are being cancelled, the document object will not catch events
		    //	since they are not being bubbled up. In order to combat this, we can attach
		    //	to every relevant item (see tlExcludeTags and tlNodeTags), except this may
		    //	result in duplicate events being captured.
		    tlUniversalAttach : false,

		    //  Option to store the xml of queued events on a page unload in a cookie, so
		    //  that it may be sent up with the next page's events. Since this may interfere
		    //  with the existing cookies on the site, this is disabled by default.
		    tlStoreQueueInCookie : false,

		    //	This is where input fields can be globally blocked.  Four examples are shown
		    //	below.  Add or remove fields as appropriate.  The parameters are:
		    //		tlfieldname     : the id of the field
		    //		caseinsensitive : check for the field name in using case
		    //			insensitive check
		    //		eventnovalue : if true, send event but without value.  If 
		    //			false do not send event
		    tlFieldBlock:[
		    	{"tlfieldname": "pi_cardNum",     "caseinsensitive": true, "eventvaluereplace": "",  "eventnovalue": true},
			    {"tlfieldname": "TLCREDITCARD",   "caseinsensitive": true, "eventvaluereplace": "",  "eventnovalue": true},
			    {"tlfieldname": "tlpassword",     "caseinsensitive": true, "eventvaluereplace": "",  "eventnovalue": true},
			    {"tlfieldname": "tlpwd",          "caseinsensitive": true, "eventvaluereplace": "",  "eventnovalue": true},
			    {"tlfieldname": "tlqty",          "caseinsensitive": true, "eventvaluereplace": "333",  "eventnovalue": false}
		    ],
	
		    tlFieldBlockMap : null,
		
		    //	This is the list of events we catch off of the window object
		    tlWindowHandlers:[
			    {"domevent": "resize",          "load": false,  "tlhandler": "TeaLeaf.Client.tlQueueResize"},
			    {"domevent": "focus",           "load": true,  "tlhandler": "TeaLeaf.Client.tlSetFocusTime"},
			    {"domevent": "help",            "load": true,  "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "scroll",          "load": false,  "tlhandler": "TeaLeaf.Client.tlQueueScroll"},
			    {"domevent": "beforeprint",     "load": false,  "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "afterprint",      "load": false,  "tlhandler": "TeaLeaf.Client.tlAddEvent"}
		    ],

		    //	This is the list of events we catch off of the document object
		    tlDocumentHandlers:[
			    {"domevent": "click",        "load": true,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "dblclick",     "load": true,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "keyup",        "load": true,     "tlhandler": "TeaLeaf.Client.tlQueueKey"},
			    {"domevent": "mousedown",    "load": false,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "mouseup",      "load": false,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "mouseover",    "load": false,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domevent": "mouseout",      "load": false,     "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    //	This event is only caught once and turned off.  This is used to 
			    //	detect robots, since a robot will never have mouse movement.
			    {"domevent": "mousemove",    "load": false,     "tlhandler": "TeaLeaf.Client.tlUserMovement"}
		    ],
		    
		    tlSingleAttach:[
			    {"domelementID": "",    "domevent": "mousedown",    "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domelementID": "",    "domevent": "mouseup",      "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domelementID": "",    "domevent": "mouseover",    "tlhandler": "TeaLeaf.Client.tlAddEvent"},
			    {"domelementID": "",    "domevent": "mouseout",     "tlhandler": "TeaLeaf.Client.tlAddEvent"}
		    ],

		    /*  tlNodeTags by default includes a list of tag names that are "unimportant"
		     *  or not rendered. The associated true/false value is used in conjunction with
		     *  tlExcludeTags - e.g. if tlExcludeTags is true and a node tag is true, it will
		     *  be excluded; if tlExcludeTags is true and a node tag is false, the tag will be
		     *  included. Similarly if tlExcludeTags is false (meaning to explicitly include the
		     *  listed node tags, those with "true" with be excluded.
		     */
		    tlNodeTags : {
		        "APPLET"    : true,
		        "ATTRIBUTE" : true,
			"B"	    : true,
		        "BASE"      : true,
			"BODY"	    : true,
		        "BR"        : true,
		        "CENTER"    : true,
		        "COL"       : true,
		        "COLGROUP"  : true,
		        "COMMENT"   : true,
			"DIV"	    : true,
		        "DEFAULT"   : true,
		        "DEL"       : true,
		        "EVENT"     : true,
		        "FONT"      : true,
			"FORM"	    : true,
			"HEAD"	    : true,
		        "HISTORY"   : true,
		        "HR"        : true,
		        "HTML"      : true,
		        "I"         : true,
		        "INS"       : true,
		        "LINK"      : true,
		        "MAP"       : true,
		        "META"      : true,
		        "NAMESPACE" : true,
		        "NAVIGGATOR" : true,
		        "NOBR"      : true,
		        "OPTION"    : true,
		        "P"         : true,
		        "PARAM"     : true,
		        "S"         : true,
		        "SCRIPT"    : true,
		        "SMALL"     : true,
		        "STRIKE"    : true,
		        "STRONG"    : true,
		        "STYLE"     : true,
		        "SUB"       : true,
		        "SUP"       : true,
		        "TH"        : true,
		        "TITLE"     : true,
		        "THEAD"     : true,
		        "TFOOT"     : true,
		        "TR"        : true,
		        "U"         : true
		    },

		    /*  tlSpecialChildNodeTags represents tags with a special
		     *  situation where the event that fires is attached to a
		     *  non-visual item that is inside the actual UI element.
                 *  Example would be a menu with a <nobr> tag inside to
                 *  keep the visual text of the menu on one line. The <nobr>
                 *  fires the event when we really want the parent menu.
		     */

		    tlSpecialChildNodeTags : {
		        "NOBR" : true,
		        "P"    : true
		    }
	    };
	    	
	    TeaLeaf.Client.Configuration.tlIdCounter = [];
    }
}

/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* This is the main UI Client Event Capture JavaScript file that is  
* used by other JavaScript to register their onload routines.
*
* @requires 
* TeaLeafCfg.js
*
* @version 2009.06.09.1
*                                                                   
*/

if(TeaLeaf && TeaLeaf.Configuration && TeaLeaf.Configuration.tlinit == false){
    TeaLeaf.Configuration.tlinit = true;
    if( ! Array.prototype.push ) {
	    Array.prototype.stackEnd = 0;
        /**
        * Add push if the browser does not supply
        * them with the Array object (IE6 and earlier)
        * @addon
        */
	    Array.prototype.push = function(obj) {
		    this[this.stackEnd] = obj;
		    this.stackEnd++;
	    }
    }
    if( ! Array.prototype.pop ) {
        /**
        * Add pop if the browser does not supply
        * them with the Array object (IE6 and earlier)
        * @addon
        */
	    Array.prototype.pop = function(obj) {
		    this.stackEnd--;
		    return this[this.stackEnd];
	    }
    }
     
    /**
    * Set TeaLeaf UI Client Event Capture as an SDK. 
    * The default behavior is not set as an SDK 
    * @requires 
    * TeaLeafCfg.js
    * @addon
    */
    TeaLeaf.settlSDK = function(){
        TeaLeaf.Configuration.tlSDK = true;
    }

    /**
    * Reset TeaLeaf UI Client Event Capture not to act as an SDK.
    * The default behavior is not set as an SDK 
    * @requires 
    * TeaLeafCfg.js
    * @addon
    */    
    TeaLeaf.resettlSDK = function(){
        TeaLeaf.Configuration.tlSDK = false;
    }

    /**
    * Checks if the browser is IE
    * @requires 
    * TeaLeafCfg.js
    * @addon
    */    
    TeaLeaf.tlIsIE = function(){ 
        if(navigator.appName.indexOf("Microsoft") >= 0 && parseInt(navigator.appVersion) >= 4){
            return true;      
        }
        return false;
    }

    /**
    * Array to store all the object that need to be loaded after the page is rendered.
    * NOTE: This will not be used if the UI Client Event Capture is used as an SDK.
    */    
    TeaLeaf.tLoadObjs = [];
    /**
    * This function is used for the other javascript files to register their
    * onload functions to be called
    * @param obj object that is registered from other JavaScript to be loaded
    * @param functionName object function that is registered from other JavaScript to be loaded 
    * @requires 
    * TeaLeafCfg.js
    * @addon
    */    
    TeaLeaf.addOnLoad = function(obj, functionName){    
	    if(arguments.length == 1) {	    
		    TeaLeaf.tLoadObjs.push(obj);
	    } else if(arguments.length > 1) {	
			TeaLeaf.tLoadObjs.push(obj[functionName]);
	    }
    }
    /**
    * This function is used to load UI Client Event Caputre or the
    * UI Client Event Capture SDK.
    * @requires 
    * TeaLeafCfg.js
    * @addon
    */    
	TeaLeaf.PageSetup = function() {
	    if(TeaLeaf.Configuration.tlSDK == false ){ 		
	        for(var i=0; i<TeaLeaf.tLoadObjs.length; i++){
                TeaLeaf.tLoadObjs[i]();	    
	        }
	    }
		TeaLeaf.EndLoad = new Date();
	}	

    if (document.addEventListener) {
	    document.addEventListener("DOMContentLoaded", TeaLeaf.PageSetup, null); // mozilla
    }   
    else {
	    if (typeof(document.readyState) != "undefined") {
		    if( typeof document.onreadystatechange == "function" ) {
			    TeaLeaf.ReadyStateChange = document.onreadystatechange;
		    }
		    else {
			    TeaLeaf.ReadyStateChange = null;
		    }
		    document.onreadystatechange = function() {
			    if(document.readyState == "complete") {
				    TeaLeaf.PageSetup();
			    }
			    if( TeaLeaf.ReadyStateChange ) {
				    TeaLeaf.ReadyStateChange();
			    }
		    }; // ie
        }
	    else {
		    if( typeof window.onload == "function" ) {
			    TeaLeaf.OnLoad = window.onload;
		    }
		    else {
			    TeaLeaf.OnLoad = null;
		    }
		    window.onload = function() {
			    TeaLeaf.PageSetup();
			    if( TeaLeaf.OnLoad ) {
				    TeaLeaf.OnLoad();
			    }
		    }; // other
	    }
    }
}

/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* Event and communication setup.   
*
* @requires 
* TeaLeaf.js
* TeaLeafEventCfg.js
*
* @version 2009.06.09.1
*                                                                   
*/
if(TeaLeaf.Event && TeaLeaf.Event.Configuration){
	try{
	    if(typeof TeaLeaf_PageID == "undefined"){
			TeaLeaf_PageID = null;
		}
	}
	catch(e){
		TeaLeaf_PageID = null;
	}
    
    TeaLeaf.Event.tlQueuedXML = "";
    /**
    * Get TeaLeaf UI Client Event content type that 
    * is sent in the HTTP headers of the TeaLeaf AJAX POST
    * that delivers the XML with the UI Cient Events to the 
    * capture device. 
    * @addon
    */
    TeaLeaf.Event.tlGetContentType = function(){
        var contentType = "text/xml";
        return contentType;
    }
    /**
    * Get TeaLeaf UI Client Event XEvent that 
    * is sent in the HTTP headers of the TeaLeaf AJAX POST
    * that delivers the XML with the UI Cient Events to the 
    * capture device. 
    * @addon
    */
    TeaLeaf.Event.tlGetTeaLeafXEvent = function(){
        var teaLeafXEvent = "ClientEvent";
        return teaLeafXEvent;
    }
    /**
    * Get TeaLeaf UI Client Event type set during
    * TeaLeaf event definition.
    * @addon
    */    
    TeaLeaf.Event.tlEventType = function(){
        return TeaLeaf.Event.SetType;
    }
    /**
    * Get TeaLeaf UI Client Event sub type set during
    * TeaLeaf event definition.
    * @addon
    */        
    TeaLeaf.Event.tlEventSubType = function(){
        return TeaLeaf.Event.SetSubType;
    }
    /**
    * Get the path relative to the host.
    * @addon
    */            
    TeaLeaf.Event.tlGetUrlPath = function(){
        var strpath = window.location.pathname;
        return strpath;
    }
    /**
    * Get TeaLeaf UI Client Event version that 
    * is sent in the HTTP headers of the TeaLeaf AJAX POST
    * that delivers the XML with the UI Cient Events to the 
    * capture device. 
    * @requires 
    * TeaLeafEventCfg.js
    * @addon
    */
    TeaLeaf.Event.tlGetJSVersion = function(){
        return TeaLeaf.Configuration.tlversion;
    }
    /**
    * Get the resolution type (0-4) based on the resolution defined in 
    * the configuration file. 
    * @param width 
    * @param height 
    * @requires 
    * TeaLeafEventCfg.js
    * @addon
    */
    TeaLeaf.Event.tlResolutionType = function(width, height){ 
        var res = TeaLeaf.Event.Configuration.tlResolution;
        for(var i=0; i<res.length; i++)
        {
            if(width <= res[i].width || height <= res[i].height)
            {
                return res[i].type;
            }
        }
        return res[length-1].type;        
    }
    /**
    * Get the browser resolution type. 
    * @requires 
    * TeaLeafEventCfg.js
    * @addon
    */
    TeaLeaf.Event.tlResolutionTypeBrowser = function(){
        var winWidth = 0;
        var winHeight = 0;  
        if(window.innerWidth){
            winWidth = window.innerWidth;
            winHeight = window.innerHeight;
        }
        else if(document.documentElement && document.documentElement.clientWidth){   
            winWidth = document.documentElement.clientWidth;
            winHeight = document.documentElement.clientHeight;
        }
        else if(document.body && document.body.clientWidth){
            winWidth = document.body.clientWidth;
            winHeight = document.body.clientHeight;
        }
        else{
            var elems = document.getElementsByTagName("body"); 
            if(elems.length > 0){
                winWidth = elems[0].clientWidth;
                winHeight = elems[0].clientHeight;
            }
        }                
        var retType = TeaLeaf.Event.tlResolutionType(winWidth, winHeight);  
        return retType;
    }
    /**
    * Get the page render time. 
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js
    * @addon
    */    
    TeaLeaf.Event.tlGetRenderTime = function(){
        return TeaLeaf.Event.PageLoadMilliSecs;
    }
    /**
    * Get element count. 
    * @param element DOM element name 
    * @addon
    */        
    TeaLeaf.Event.tlGetElementCount = function(element){
        return document.getElementsByName(element).length;		   	
    }
    /**
    * Get count of broaken images. 
    * @addon
    */            
    TeaLeaf.Event.tlBadImageCount = function() {
		var	cnt = 0;
		var ind;
		for(ind = 0; ind < document.images.length; ind++) {
			var	img = document.images[ind];
			//	IE correctly identifies any images that weren't downloaded as
			//	not complete. Others should too. Gecko-based browsers act
			//	like NS4 in that they report this incorrectly.
    		if (!img.complete) {
        		cnt++;
				continue;
    		}
    		// However, they do have two very useful properties: naturalWidth and
    		// naturalHeight. These give the true size of the image. If it failed
    		// to load, either of these should be zero.
    		if (typeof img.naturalWidth != "undefined" && img.naturalWidth == 0) {
        		cnt++;
    		}
    	}
    	return cnt;
	}	
    /**
    * Get TeaLeaf current event count. 
    * @addon
    */            	
	TeaLeaf.Event.tlGetEventCount = function(){
        return TeaLeaf.Event.Configuration.tleventcount;		   	
    }
    /**
    * Get sent sting length. 
    * @param sendStr get lenght of sendStr
    * @addon
    */            	
    TeaLeaf.Event.tlGetSendStringBytes = function(sendStr){
        return sendStr.length;		   	
    }
    /**
    * Get user dwell time on a page.
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js 
    * @addon
    */            	
    TeaLeaf.Event.tlGetDwellTime = function(){
        return TeaLeaf.Event.tlDateDiff(TeaLeaf.tlStartLoad, TeaLeaf.Event.Configuration.tllastdwelltime);
    }
    /**
    * Get the ID of the last visited DOM element that we have listeners attached.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	    
    TeaLeaf.Event.tlGetLastVisitedElementID = function(){
        return TeaLeaf.Event.Configuration.tlidoflastvisitedcontrol;
    }
    /**
    * Get the date difference between two values.
    * @param v1 first time value 
    * @param v2 second time value 
    * @addon
    */            	        
    TeaLeaf.Event.tlDateDiff = function(v1, v2) {
		return Math.abs(v1-v2);
	}
    /**
    * Get the XForm path string with ids or names in fill out order.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	    	
	TeaLeaf.Event.tlGetVisitOrder= function(){
	    return TeaLeaf.Event.Configuration.tlvisitorder;
	}
    /**
    * Re-format the XML.
    * @param Str containing XML to be re-formated 
    * @addon
    */            	        
    TeaLeaf.Event.tlFormatXML = function(Str) {
        if (Str) {
			if( Str.replace ) {
            	return Str.replace(/&/g, "&amp;").replace(/\"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
			}
			return Str;
		}
        return "";
    }
    /**
    * Get cookie value.
    * @param name cookie name 
    * @addon
    */            	            
    TeaLeaf.Event.tlGetCookie = function(name){
	    var dc = document.cookie;
	    var prefix = name + "=";
	    var begin = dc.indexOf("; " + prefix);
	    if (begin == -1) {
		    begin = dc.indexOf(prefix);
		    if (begin != 0) {
			    return "";
		    }
	    }
	    else {
		    begin += 2;
	    }
	    var end = document.cookie.indexOf(";", begin);
	    if (end == -1) {
		    end = dc.length;
	    }
	    return unescape(dc.substring(begin + prefix.length, end));
    }  
    /**
    * Set HTTP headers.
    * @param tlreq XMLHTTPRequest object 
    * @param tlheaderconfig JSON array with the HTTP header field values. 
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js 
    * @addon
    */            	
    TeaLeaf.Event.tlSetHTTPHeaders = function(tlreq, tlheaderconfig){    
        for(var i=0; i<tlheaderconfig.length; i++) {
		    if(tlheaderconfig[i].tlsethttpheader == true){
			    tlreq.setRequestHeader(tlheaderconfig[i].tlreqhttpheadername, eval(tlheaderconfig[i].tlreqhttpheadervalue));
			}
        }
    }
    /**
    * Get TeaLeaf page id.
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js 
    * @addon
    */            	    
    TeaLeaf.Event.tlGetPageId = function(){
	    //	Have we already calculated this?
	    if(TeaLeaf.Event.Configuration.tlpageid) {
		    return TeaLeaf.Event.Configuration.tlpageid;
	    }
	    //	No cookie.  Look for the page id variable that will be
	    //	set by javascript outside of TeaLeaf.js
	    if( TeaLeaf_PageID ) {
			TeaLeaf.Event.Configuration.tlpageid = TeaLeaf_PageID;
			return TeaLeaf.Event.Configuration.tlpageid;
	    }
    
	    //	Neither of the above options, go ahead and generate the
	    //	page id from a time stamp.
	    TeaLeaf.Event.Configuration.tlpageid = "ID" + TeaLeaf.tlStartLoad.getHours() + "H" +
		    			TeaLeaf.tlStartLoad.getMinutes() + "M" +
			    		TeaLeaf.tlStartLoad.getSeconds() + "S" +
				    	TeaLeaf.tlStartLoad.getMilliseconds()+ "R"+
				    	Math.random();
	    return TeaLeaf.Event.Configuration.tlpageid;
    }
    /**
    * Send failure message.
    * @param url url 
    * @param failedUrl url where failure occured 
    * @param message failure message 
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js 
    * @addon
    */            	    
    TeaLeaf.Event.tlSendFailure = function(url, failedUrl, message){
	    var tlnow = new Date();
	    var	t1970 = Date.UTC(tlnow.getUTCFullYear(),tlnow.getUTCMonth(),tlnow.getUTCDate(), tlnow.getUTCHours(),tlnow.getUTCMinutes(),tlnow.getUTCSeconds(), tlnow.getUTCMilliseconds());
    
	    var tltimeDur;
	    if( TeaLeaf.tlStartLoad ) {
		    tltimeDur = TeaLeaf.Event.tlDateDiff(tlnow, TeaLeaf.tlStartLoad);
	    }

	    TeaLeaf.Event.Configuration.tleventcount++;
	    tlsendStr = "<ClientEvent count=\"" + TeaLeaf.Event.Configuration.tleventcount +
	    		  "\" Type=\"INFO\" SubType=\"EXCEPTION\" " +
		    	  "PageId=\""        + TeaLeaf.Event.tlGetPageId()+ "\" " +
			      "FailedUrl=\""     + TeaLeaf.Event.tlFormatXML(failedUrl) + "\" " +
			      "Message=\""       + TeaLeaf.Event.tlFormatXML(message)   + "\" " +
			      "TimeDuration=\""  + tltimeDur + "\" " +
			      "DateSince1970=\"" + t1970 + "\" />\r\n";

	    //	Send the request
	    try {
	        TeaLeaf.Event.Configuration.tlasync = true;
	        var tlExceptionEvent = new TeaLeaf.Event("INFO", "EXCEPTION");
		    tlExceptionEvent.tlSendXML(tlsendStr,true);
	    }   
	    catch(exc) {
	        if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
			    alert(exc.name + ": " + exc.message + "\r\n\r\nPos 4");
			}
	    }
    }   
    /**
    * Create the XMLHTTPRequest transport object.
    * @addon
    */            	                      
    TeaLeaf.Event.tlGetTransport = function(){
	    var	tlreq;
	    if(window.XMLHttpRequest) {
		    try {
			    tlreq = new XMLHttpRequest();
		    }
		    catch(e) {
			    tlreq = null;
		    }
	    }
	    else if(window.ActiveXObject) {
		    try {
			    tlreq = new ActiveXObject("Msxml2.XMLHTTP");
		    }
		    catch(e) {
			    try {
			    	tlreq = new ActiveXObject("Microsoft.XMLHTTP");
			    }
			    catch(e) {
				    tlreq = null;
			    }
		    }
	    }
	    return tlreq;
    }

    TeaLeaf.Event.TransportArray = [];
    
    /**
    * Get the XMLHTTPRequest transport object from the Transport Array if not create one.
    * @addon
    */            	                      
    TeaLeaf.Event.tlXMLHTTPObj = function(){   
 	    var i = 0;
	    for(; i < TeaLeaf.Event.TransportArray.length; i++) {
    		if( TeaLeaf.Event.TransportArray[i] && TeaLeaf.Event.TransportArray[i].readyState > 0 ) {
			    if( TeaLeaf.Event.TransportArray[i].readyState == 4 ) {
    				TeaLeaf.Event.TransportArray[i].abort();
    				TeaLeaf.Event.TransportArray[i].onreadystatechange = new function() {};
				    return TeaLeaf.Event.TransportArray[i];
			    }
		    }
		    else {
    			TeaLeaf.Event.TransportArray[i] = TeaLeaf.Event.tlGetTransport();
    			return TeaLeaf.Event.TransportArray[i];
		    }
	    }
	    //	Nope, we need another
    	TeaLeaf.Event.TransportArray[i] = TeaLeaf.Event.tlGetTransport();
    	return TeaLeaf.Event.TransportArray[i];
    }  
    /**
    * Clean the XMLHTTPRequest Transport Array.
    * @addon
    */            	                          
    TeaLeaf.Event.tlCleanXMLHTTPObj = function(obj){
	    //	Zap this one!
	    var i = 0;
	    for(; i < TeaLeaf.Event.TransportArray.length; i++) {
		    if( obj == TeaLeaf.Event.TransportArray[i] ) {
    			TeaLeaf.Event.TransportArray[i] = null;
		    }
	    }   
    }
    /**
    * Add event handler.
    * @param tlitem element that we attach a listener
    * @param tlevt event that we listen for
    * @param tlhandler event handler
    * @addon
    */            	                              
    TeaLeaf.Event.tlAddHandler = function(tlitem, tlevt, tlhandler, tlcapture) {		
		try {
			    if( tlitem.addEventListener ) {
					if(navigator.userAgent.toLowerCase().indexOf('safari')!=-1){
						    tlitem.addEventListener('on'+tlevt, tlhandler, tlcapture);                                          
					}
					else{
						    tlitem.addEventListener(tlevt, tlhandler, tlcapture);
					}
			    }
			    else if( tlitem.attachEvent ) {
					tlitem.attachEvent('on'+tlevt, tlhandler);
			    }
		}
		catch(exc) {
			    if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
					alert(exc.name + ": " + exc.message + "\r\n\r\nPos 4");
			    }
		}
	}	
    /**
    * Remove event handler.
    * @param tlitem element that we attached a listener
    * @param tlevt event that we listened
    * @param tlhandler event handler
    * @addon
    */            	                              
	TeaLeaf.Event.tlRemoveHandler = function(tlitem, tlevt, tlhandler, tlcapture) {
		try {
			if( tlitem.removeEventListener ) {
				tlitem.removeEventListener(tlevt, tlhandler, tlcapture);
			}
			else if( tlitem.detachEvent ) {
				tlitem.detachEvent('on'+tlevt, tlhandler);
			}
		}
		catch(exc) {
			if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
				alert(exc.name + ": " + exc.message + "\r\n\r\nPos 5");
			}
		}
	}
    /**
    * Flush the event queue.
    * @param force forces the flush if true
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js 
    * TeaLeafEventCfg.js 
    * @addon
    */            	                              
	TeaLeaf.Event.tlFlushQueue = function(force) {
		var	dataToSend = null;
		var	queueTime = TeaLeaf.Event.Configuration.tlqueueeventstimer;
		var maxTime = queueTime * 3;
		//	Nothing to send
		if(TeaLeaf.Event.Configuration.tlusetopqueue) {
			var now = new Date();
			var diff = (now - top.TeaLeaf.Event.TimeSent);		
			//	If we have queued data, let's send it if appropriate
			if( top.TeaLeaf.Event.tlQueuedXML ) {
				if( force || diff >= queueTime ) {
					dataToSend = top.TeaLeaf.Event.tlQueuedXML;
					top.TeaLeaf.Event.tlQueuedXML = "";
					top.TeaLeaf.Event.TimeSent = now;
				}
			}
			//	Nothing to send
			if( ! dataToSend ) {
				if( ! force && diff < (queueTime / 2) ) {
					//	A little heuristics here--If the time is less than
					//	1/2 the standard time, then assume another frame
					//	is handling the send.  Slow down the transmission
					//	time for this frame.
					
					// we need to do this so we do not end up waiting infinately.
					if(queueTime >= maxTime){
					    queueTime = maxTime;
					}
					else{
					    queueTime = (queueTime * 3) / 2;
					}
				}
				return queueTime;
			}
		}
		else {
			if( ! TeaLeaf.Event.tlQueuedXML ) {
				return queueTime;
			}
			dataToSend = TeaLeaf.Event.tlQueuedXML;
			TeaLeaf.Event.tlQueuedXML = "";
		}
		
		//	Get the Event
		var evt = new TeaLeaf.Event("GUI", "QUEUED");
		evt.tlSendXML(dataToSend);
		return queueTime;

    }
    /**
    * Push XML on the stack.
    * @param tag tag name
    * @addon
    */            	                              
    TeaLeaf.Event.prototype.tlPushXML = function(tag){
	    if( ! this.XMLStack ) {
		    this.XMLStack = [];
    	}
	    
	    var strTag = "  <" + tag;
	    if(this.XMLData){
	        this.XMLData += strTag;
	    }
	    else{
	        this.XMLData = strTag;
	    }
    }    
    /**
    * Pop XML from the stack.
    * @param tag tag name
    * @addon
    */            	                              
    TeaLeaf.Event.prototype.tlPopXML = function(){
        if(this.XMLData){
	        this.XMLData += " />\r\n";
	    }
	    else{
            return false;
	    }
    }   
    /**
    * Add data tot he XML stack.
    * @param name0 name of the XML attribute.
    * @param value0 value of the XML attribute.
    * @addon
    */            	                              
    TeaLeaf.Event.prototype.tlAddData = function(nameValueArray){
	    var offset = "";
	    if( this.XMLStack ) {
		    for(var ind = 0; ind < this.XMLStack.length; ind++) {
			    offset += "  ";
		    }		    
	    }	    

		var parts = [];
	    for(var ind = 0; ind < nameValueArray.length; ind += 2) {
			var name = nameValueArray[ind];
			tlValue = TeaLeaf.Event.tlFormatXML(nameValueArray[ind+1]);
			if(name && tlValue)	
				parts[parts.length] = offset + " " + name + "=" + "\""+tlValue+"\"";
		}

		if(!this.XMLData) this.XMLData = "";
		this.XMLData += parts.join("");

	    delete nameValueArray;
    }   
    /**
    * Send the XML with the UI Client Events including the HTTP headers if set.
    * @param tlsendStr XML message
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                              
    TeaLeaf.Event.prototype.tlSendXML = function(tlsendStr, tlignoresendfailure ){
	    // Get an the request object
	    var tlreq = TeaLeaf.Event.tlXMLHTTPObj();
	    if( ! tlreq ) {
		    return;
	    }
	    //	Send the request
	    try {
		    var	tlurl = this.theUrl;
		    tlreq.onreadystatechange = function(code) {
			    if(tlreq.readyState == 2 && typeof TeaLeaf.Cookie != "undefined")
			    {
				// Clear the queued xml stored in the cookie, by clearing the contents and setting the expiration to a day before
				// Done on readyState == 2, which means data has been sent and is waiting on a server response
				var d = new Date();
				d.setTime(d.getTime()-86400000);
				TeaLeaf.Cookie.tlSetCookieValue("tlQueuedXML", "", d, "/");
			    }

			    if( tlreq.readyState == 4 ) {
				    //	The try/catch is to catch a netscape bug
				    //	https://bugzilla.mozilla.org/show_bug.cgi?id=238559#c0
				    //	Thanks to JS for the help
				    try {
					    if( tlreq.status != 200 && tlreq.status != 304 ) {

		                if(TeaLeaf.Event.Configuration.tlignoresendfailure == true){
					        TeaLeaf.Event.Configuration.tlignoresendfailure = false;
           				    TeaLeaf.Event.tlSendFailure(tlurl, tlurl, "Status " + tlreq.status + ": " + tlreq.statusText);
						    }
					    }
			    	}
				    catch(e) {
				    }
			    }
		    }
		    		    
		    tlreq.open("POST", tlurl, TeaLeaf.Event.Configuration.tlasync);
			TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet);

            //Set the TeaLeaf HTTP Header Values		
            if( TeaLeaf.Event.Configuration.tlinitflag == true ){           
                TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit);
            }
            if( TeaLeaf.Event.Configuration.tlbeforeunloadflag == true ){
                TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload);
            }  
            var tlposttime = new Date();
            var tlpostmilisec = Date.UTC(tlposttime.getUTCFullYear(),tlposttime.getUTCMonth(),tlposttime.getUTCDate(), tlposttime.getUTCHours(),tlposttime.getUTCMinutes(),tlposttime.getUTCSeconds(), tlposttime.getUTCMilliseconds());
            var tlPostTimeStamp = "<ClientEventSet PostTimeStamp=\""+tlpostmilisec+"\" >";
            tlsendStr = tlPostTimeStamp + tlsendStr + "</ClientEventSet>";
    	    tlreq.send(tlsendStr);
    	}
	    catch(exc) {
		    if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
			    if( exc.name ) {
				    alert(exc.name + ": " + exc.message + "\r\n\r\nURL: " + this.theUrl + "\r\n\r\nPos 3 ");
			    }
			    else {
				    alert(exc + "\r\n\r\nURL: " + this.theUrl + "\r\n\r\nPos 3 ");
			    }
		    }	    
		    if(TeaLeaf.Event.Configuration.tlignoresendfailure == true){
                TeaLeaf.Event.Configuration.tlignoresendfailure = false;
		        TeaLeaf.Event.tlSendFailure(this.theUrl, this.theUrl, exc);
		    }  
		 TeaLeaf.Event.tlCleanXMLHTTPObj(tlreq);
	    }
    }
    /**
    * Depending on the configuration settings send the XML or queue the XML message.
    * @requires
    * TeaLeaf.js
    * TeaLeafCfg.js
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                  
    TeaLeaf.Event.prototype.tlSend = function(bRoot){
	    //	Pop everything on the queue
	    if( this.XMLStack ) {
		    while( this.XMLStack.length > 0 ) {
			    this.tlPopXML()
		    }
	    }
	    var	t1970 = Date.UTC(this.date.getUTCFullYear(),this.date.getUTCMonth(),this.date.getUTCDate(), 
	                    this.date.getUTCHours(),this.date.getUTCMinutes(),this.date.getUTCSeconds(), this.date.getUTCMilliseconds());
	    var timeDur;
	    if( TeaLeaf.tlStartLoad ) {
		    timeDur = TeaLeaf.Event.tlDateDiff(this.date, TeaLeaf.tlStartLoad);
	    }

	    TeaLeaf.Event.Configuration.tleventcount++;
	    sendStr = "<ClientEvent count=\"" + TeaLeaf.Event.Configuration.tleventcount +
			  "\" Type=\"" + this.EventType + "\" SubType=\"" + this.EventSubType+"\"";
	    if( this.EventSource ) {
		    sendStr = sendStr + "\" Source=\"" + this.EventSource+ "\"";
	    }
	    if(bRoot){
	        sendStr = sendStr + 
		    	    " PageId=\""        + TeaLeaf.Event.tlGetPageId() +"\""+
			        " TimeDuration=\""  + timeDur + "\""+
			        " DateSince1970=\"" + t1970 +
			        "\" >\r\n" +
			        this.XMLData +
			        "</ClientEvent>\r\n";
	    }
	    else{
	        sendStr = sendStr + 
		    	    " PageId=\""        + TeaLeaf.Event.tlGetPageId() +"\""+
			        this.XMLData        +
			        " TimeDuration=\""  + timeDur + "\""+
			        " DateSince1970=\"" + t1970 +
			        "\" />\r\n";
	    }
	    //	Queue the event
	    if( TeaLeaf.Event.Configuration.tlqueueevents ) {
			if( TeaLeaf.Event.Configuration.tlusetopqueue ) {
				if( top.TeaLeaf.Event.tlQueuedXML ) {
					top.TeaLeaf.Event.tlQueuedXML += sendStr;
				}
				else {
					top.TeaLeaf.Event.tlQueuedXML = sendStr;
				}
			}
			else {
				if( TeaLeaf.Event.tlQueuedXML ) {
					TeaLeaf.Event.tlQueuedXML += sendStr;	
				}
				else {
					TeaLeaf.Event.tlQueuedXML = sendStr;
				}
			}
			//	Check the size of the XML.  IF it is getting too
			//	big, send it
			if( TeaLeaf.Event.Configuration.tlqueueeventsmaxsz < TeaLeaf.Event.tlQueuedXML.length ) {	    	
	    		TeaLeaf.Event.tlFlushQueue();
			}
			return;
	    }
	    //	Send the request
	    try {
		    this.tlSendXML(sendStr);
		    this.XMLData = "";
	    }
    	catch(exp) {
	    }
	    this.XMLData = "";
    }

    /**
    * Encode a string to be suitable for an XML attribute.
    * @param str
    * @addon
    */            	                              
    TeaLeaf.Event.tlXMLEncode = function(str){
	    if(str == null) return str;
	    str = str.replace(/&/g, "&#38;");
	    str = str.replace(/"/g, "&#34;");
	    str = str.replace(/'/g, "&#39;");
	    str = str.replace(/:/g, "&#58;");
	    return str;
    }   

    /**
    * Decode a string encoded with tlXMLEncode.
    * @param str
    * @addon
    */            	                              
    TeaLeaf.Event.tlXMLDecode = function(str){
	    if(str == null) return str;
	    str = str.replace(/&#58;/g, ":");
	    str = str.replace(/&#39;/g, "'");
	    str = str.replace(/&#34;/g, "\"");
	    str = str.replace(/&#38;/g, "&");
	    return str;
    }

    /**
    * Enable HTTP Headers defined in the TeaLeafEventCfg.js.
    * @param obj determines what set of HTTP headers to be set. 
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlEnableAllHTTPHeaders = function(obj) {         
        if(obj){
            if(obj == "info"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, "all");            
            }
            else if(obj == "init"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, "all");
            }
            else if(obj == "beforeunload"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, "all");
            } 
        } 
        else{
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, "all");            
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, "all");
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, "all");        
        }        
    }
    /**
    * Enable HTTP Headers defined in the TeaLeafEventCfg.js.
    * @param obj determines what set of HTTP headers to be set. 
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlEnableHTTPHeader = function(obj, headerName) { 
        if(obj == "info"){
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, headerName);            
        }
        else if(obj == "init"){
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, headerName);
        }
        else if(obj == "beforeunload"){
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, headerName);
        } 
    }
    /**
    * Disable HTTP Headers defined in the TeaLeafEventCfg.js.
    * @param obj determines what set of HTTP headers to be set. 
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlDisableAllHTTPHeaders = function(obj) {         
        if(obj){
            if(obj == "info"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, false, "all");            
            }
            else if(obj == "init"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, false, "all");
            }
            else if(obj == "beforeunload"){
                TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, false, "all");
            } 
        } 
        else{
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, false, "all");            
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, false, "all");
            TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, false, "all");        
        }        
    }    
    /**
    * Enable queuing of events.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlEnableQueueEvents = function() { 
        TeaLeaf.Event.Configuration.tlqueueevents = true; 
    }  
    /**
    * Disable queuing of events.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlDisableQueueEvents = function() { 
        TeaLeaf.Event.Configuration.tlqueueevents = false; 
    }   
    /**
    * Enable showing of exception in an alert message.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                   
    TeaLeaf.Event.tlEnableShowExceptions = function() { 
        TeaLeaf.Event.Configuration.tlshowexceptions = true; 
    }
    /**
    * Disable showing of exception in an alert message.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlDisableShowExceptions = function() { 
        TeaLeaf.Event.Configuration.tlshowexceptions = false; 
    } 
    /**
    * Set queue event flush time.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlSetQueueEventTime = function(tlvalue) { 
    
        TeaLeaf.Event.Configuration.tlqueueeventstimer = tlvalue; 
    }  
    /**
    * Get queue event flush time.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlGetQueueEventTime = function() { 
        return TeaLeaf.Event.Configuration.tlqueueeventstimer; 
    }
    /**
    * Set queue event maximum size.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlSetQueueEventMaxSize = function(tlvalue) { 
        TeaLeaf.Event.Configuration.tlqueueeventsmaxsz = tlvalue; 
    }    
    /**
    * Get queue event maximum size.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlGetQueueEventMaxSize = function() { 
        return TeaLeaf.Event.Configuration.tlqueueeventsmaxsz; 
    } 
    /**
    * Set the url where TeaLeaf posts.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlSetPostURL = function(tlvalue) { 
        TeaLeaf.Event.Configuration.tlurl = tlvalue; 
    }
    /**
    * Get the url where TeaLeaf posts.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlGetPostURL = function() { 
        return TeaLeaf.Event.Configuration.tlurl; 
    }  
    /**
    * Set page id cookie value.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlSetPageIDCookie = function(tlvalue) { 
        TeaLeaf.Event.Configuration.tlpageidcookie = tlvalue; 
    }
    /**
    * Get page id cookie value.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlGetPageIDCookie = function(tlvalue) { 
        return TeaLeaf.Event.Configuration.tlpageidcookie; 
    }   
    /**
    * JSON configuration utility allowing to enable/disable certain DOM events
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
    TeaLeaf.Event.tlEventJSONCfgUtil = function(tlJSONConfig, tlEnable, domEventName) {         
        for(var i = 0; i<tlJSONConfig.length; i++){
            if(domEventName == "all"){
                tlJSONConfig[i].load = tlEnable;
            }
            else if (domEventName == tlJSONConfig[i].domevent){
                tlJSONConfig[i].load = tlEnable;
            }
        }  
    }  
    /**
    * Error handler.
    * @param message error 
    * @param url url
    * @param line line where error occured
    * @requires   
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
	TeaLeaf.Event.tlErrorHandler = function(message, url, line) {	
		var	now = new Date();
		if( ! line ) {
			line = "unknown";
		}
		var	tlevt = new TeaLeaf.Event("INFO", "EXCEPTION");
		var tlAddNameValueArray = ["Message", message, 
			                       "URL", escape(url), 
			                       "Line", line];
        tlevt.tlAddData(tlAddNameValueArray);
        TeaLeaf.Event.Configuration.tlasync = true;
		tlevt.tlSend();
		TeaLeaf.Event.tlFlushQueue();
		return false;
	}	
	/**
    * Handle the before unload event and flush the queue of events.
    *
    * @requires 
    * TeaLeafEventCfg.js
    * @addon
    */            	                                                                			
	TeaLeaf.Event.tlBeforeUnload = function(){
	    if(TeaLeaf.Event.Configuration.tleventbeforeunloadflag == true){ 
            TeaLeaf.Event.Configuration.tleventunloadflag = false;   
		    //	Send in the notice
		    var	tlevt = new TeaLeaf.Event("PERFORMANCE", "BeforeUnload");	
		    TeaLeaf.Event.SetType = tlevt.EventType;

		    if(TeaLeaf.Event.SetSubType == ""){
                TeaLeaf.Event.SetSubType = tlevt.EventSubType;
            }
            else{
                TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType;
            }                    
            TeaLeaf.Event.Configuration.tlbeforeunloadflag = true;
            TeaLeaf.Event.Configuration.tlignoresendfailure = true;
 	        TeaLeaf.Event.Configuration.tlasync = false;
 		    tlevt.tlSend();  
		    TeaLeaf.Event.tlFlushQueue(true);
		}	
        TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false);
        TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false);
	}
	/**
    * Handle the unload event and flush the queue of events.
    *
    * @requires 
    * TeaLeafEventCfg.js
    * @addon
    */            	                                                                				
	TeaLeaf.Event.tlUnload = function(){
        if(TeaLeaf.Event.Configuration.tleventunloadflag ){         
            TeaLeaf.Event.Configuration.tllastdwelltime = new Date();
            TeaLeaf.Event.Configuration.tleventbeforeunloadflag = false;

		    //	Send in the notice
		    var	tlevt = new TeaLeaf.Event("PERFORMANCE", "Unload");
		    TeaLeaf.Event.SetType = tlevt.EventType;
		    
		    if(TeaLeaf.Event.SetSubType == ""){
                TeaLeaf.Event.SetSubType = tlevt.EventSubType;
            }
            else{
                TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType;
            }
            TeaLeaf.Event.Configuration.tlignoresendfailure = true;
            TeaLeaf.Event.Configuration.tlasync = false;
		    tlevt.tlSend();
		    TeaLeaf.Event.tlFlushQueue(true);
        }  
        TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false);
        TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false);
	}
	
    /**
    * Event setup.
    * @requires
    * TeaLeafEventCfg.js 
    * @addon
    */            	                                       
	TeaLeaf.Event.EventSetup = function() {
        //Handle Errors
        if(TeaLeaf.Event.Configuration.tlcatcherrors){
            TeaLeaf.Event.tlAddHandler(window, "error", TeaLeaf.Event.tlErrorHandler, false);                
        }
        if(!TeaLeaf.Client){
            TeaLeaf.Event.tlAddHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false);
            TeaLeaf.Event.tlAddHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false);
        }
		//	If we are queueing events, set up the timer
		if( TeaLeaf.Event.Configuration.tlqueueevents ) {
			TeaLeaf.Event.tlTimerRoutine = function() {
				//	Amount of time until the next timeout
				var	timeAmount = TeaLeaf.Event.Configuration.tlqueueeventstimer;
				try {
					timeAmount = TeaLeaf.Event.tlFlushQueue();
				}
				catch(exc) {
					if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
						alert(exc.name + ": " + exc.message + "\r\n\r\nPos 7");
					}
				}
				//NOTE:  Use setTimeout instead of setInterval since
				//	setInterval is only JS 1.2 and later
				setTimeout('TeaLeaf.Event.tlTimerRoutine()', timeAmount);
			}
			setTimeout('TeaLeaf.Event.tlTimerRoutine()', TeaLeaf.Event.Configuration.tlqueueeventstimer);
		}
    	TeaLeaf.Event.Loaded = true;
	}
	//	Get the appropriate URL
	var	tmpUrl;
	if( window.location.protocol == "http:" ) {
    	tmpUrl = TeaLeaf.Event.Configuration.tlurl;
	}
	else {
    	tmpUrl = TeaLeaf.Event.Configuration.tlsecureurl;
	}

    TeaLeaf.Event.prototype.theUrl = window.location.protocol + "//" + window.location.host + tmpUrl;
	
	if(TeaLeaf.Event.Configuration.tlinit == false){
	    TeaLeaf.Event.Configuration.tlinit = true;
        TeaLeaf.Event.prototype.XMLData = "";  
        TeaLeaf.addOnLoad(TeaLeaf.Event.EventSetup); 
    }
}
/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview
* This file sends Summary about Window, Document, Navigator and Screen 
* objects rendered on the page.
* 
* @requires 
* TeaLeaf.js
* TeaLeafEnvCfg.js
* TeaLeafEvent.js
*
* @version 2009.06.09.1
*                                                                   
*/
if(TeaLeaf.Env && TeaLeaf.Env.Configuration) {		
	/**
    * Send a page summary about Window, Document, Navigator and Screen 
    * object when the page is loaded.
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                       
	TeaLeaf.Env.tlSendPageSummary = function() {
	    if( TeaLeaf.Configuration.tlSDK == false ){	    
	        if( TeaLeaf.Env.Configuration.tlinitpost == true ) {                 
                TeaLeaf.Env.Configuration.tlinitpost = false; 
                var tlevt = new TeaLeaf.Event("PERFORMANCE", "INIT");
			    TeaLeaf.Event.PageLoadMilliSecs = TeaLeaf.Event.tlDateDiff(TeaLeaf.tlStartLoad, tlevt.date);
                TeaLeaf.Event.SetType = tlevt.EventType;
                
                if(TeaLeaf.Event.SetSubType == ""){
                    TeaLeaf.Event.SetSubType = tlevt.EventSubType;
                }
                else{
                    TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType;
                }
                TeaLeaf.Event.Configuration.tlinitflag = true;                
                TeaLeaf.Env.tlInfo(tlevt);    
                TeaLeaf.Env.tlDOMDocumentInfo(tlevt);
                TeaLeaf.Env.tlDOMWindowInfo(tlevt);
                TeaLeaf.Env.tlDOMNavigatorInfo(tlevt);
                TeaLeaf.Env.tlDOMScreenInfo(tlevt);
                TeaLeaf.Env.tlPluginInfo(tlevt);
			    tlevt.tlSend(true);
            }
	    }
    }
	/*
    * Gather Basic Info.
    * @param tlevt TeaLeaf event used for reporting on the Document object.  
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlInfo = function(tlevt){
        tlevt.tlPushXML("Info");
        var tlAddNameValueArray = ["PageLoadMilliSecs", TeaLeaf.Event.tlGetRenderTime(),
				                   "Version", TeaLeaf.Event.tlGetJSVersion(), 
				                   "TimezoneOffset", tlevt.date.getTimezoneOffset()];
        tlevt.tlAddData(tlAddNameValueArray);  
        tlevt.tlPopXML();
    }
    
	/*
    * Gather Information about the Document object.
    * @param tlevt TeaLeaf event used for reporting on the Document object.  
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlDOMDocumentInfo = function(tlevt){
        tlevt.tlPushXML("Document");
        var tlAddNameValueArray1 = ["URL", document.URL,
		                            "Title", document.title,
						            "Referer", document.referer,
						            "ContentType", document.contentType,
						            "LastModified", document.lastModified,
						            "CharacterSet", document.characterSet,
						            "Height", document.height,
						            "Width", document.width];
		tlevt.tlAddData(tlAddNameValueArray1);
        var tlAddNameValueArray2 = ["Anchors", document.anchors.length,
						            "Applets", document.applets.length,
						            "Embeds", document.embeds.length,
						            "Forms", document.forms.length,
						            "Images", document.images.length,
						            "BadImages", TeaLeaf.Event.tlBadImageCount(),
						            "Links", document.links.length,
						            "Plugins", document.plugins.length];
		tlevt.tlAddData(tlAddNameValueArray2);
		tlevt.tlPopXML();
    }
	/**
    * Gather Information about the Window object.
    * @param tlevt TeaLeaf event used for reporting on the Window object.
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlDOMWindowInfo = function(tlevt){
	    tlevt.tlPushXML("Window");
	    var tlAddNameValueArray = ["WindowHref", escape(window.location.href),
						           "WindowProtocol", window.location.protocol,
						           "WindowHost", window.location.host,
						           "WindowHostName", window.location.hostname,
						           "WindowPort", window.location.port,
						           "WindowPathName", window.location.pathname];	
		tlevt.tlAddData(tlAddNameValueArray);
		if( window.innerHeight && window.innerWidth ) {
		    var tlAddNameValueArrayWinClientSize = ["ClientSize", window.innerHeight + "x" + window.innerWidth];
		    tlevt.tlAddData(tlAddNameValueArrayWinClientSize);
		}
		else if(document.body) {
		    if(document.body.clientWidth && document.body.clientHeight){
		        var tlAddNameValueArrayDocClientSize = ["ClientSize", document.body.clientHeight + "x" + document.body.clientWidth];
                tlevt.tlAddData(tlAddNameValueArrayDocClientSize);
            }
		}
		var tlAddNameValueArrayScreen = ["FullScreen", navigator.fullScreen,
						                 "Frames", window.frames.length];
        tlevt.tlAddData(tlAddNameValueArrayScreen);
		tlevt.tlPopXML();
    }
	/**
    * Gather Information about the Navigator object.
    * @param tlevt TeaLeaf event used for reporting on the Navigator object.
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlDOMNavigatorInfo = function(tlevt){
	    tlevt.tlPushXML("Navigator");
		//	Navigator Info
		var tlAddNameValueArray = ["AppCodeName", navigator.appCodeName,
						"AppName", navigator.appName,
						"AppVersion", navigator.appVersion,
						"BrowserLanguage", navigator.browserLanguage,
						"CookieEnabled", navigator.cookieEnabled,
						"CPUClass", navigator.cpuClass,
						"Language", navigator.language,
						"OSCPU", navigator.oscpu,
						"Platform", navigator.platform,
						"Product", navigator.product,
						"SystemLanguage", navigator.systemLanguage,
						"UserAgent", navigator.userAgent,
						"UserLanguage", navigator.userLanguage,
						"Vendor", navigator.vendor,
						"VendorSub", navigator.vendorSub];
		tlevt.tlAddData(tlAddNameValueArray);
		tlevt.tlPopXML();
    }    
	/**
    * Gather Information about the Screen object.
    * @param tlevt TeaLeaf event used for reporting on the Navigator object.
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlDOMScreenInfo = function(tlevt){ 
 	    tlevt.tlPushXML("Screen");
		//	Screen Info
		var tlAddNameValueArray = ["AvailHeight", screen.availHeight,
						           "AvailLeft", screen.availLeft,
						           "AvailTop", screen.availTop,
						           "AvailWidth", screen.availWidth,
						           "BufferDepth", screen.bufferDepth,
						           "ColorDepth", screen.colorDepth,
						           "DeviceXDPI", screen.deviceXDPI,
						           "DeviceYDPI", screen.deviceYDPI,
						           "FontSmoothingEnabled", screen.fontSmoothingEnabled,
						           "Height", screen.height,
						           "Left", screen.left,
						           "LogicalXDPI", screen.logicalXDPI,
						           "LogicalYDPI", screen.logicalYDPI,
						           "Top", screen.top,
						           "UpdateInterval", screen.updateInterval,
						           "Width", screen.width];
		tlevt.tlAddData(tlAddNameValueArray);	
		tlevt.tlPopXML();

    }
	/**
    * Gather Information about the available plugins.
    * @param tlevt TeaLeaf event used for reporting on available plugins.
    * @requires
    * TeaLeafEvent.js 
    * @addon
    */            	                                           
    TeaLeaf.Env.tlPluginInfo = function(tlevt){  
        if(window.ActiveXObject){
            for (var i = 0; i <TeaLeaf.Env.Configuration.tlPlugins.length; i++) {
                if(TeaLeaf.Env.Configuration.tlPlugins[i].tlenable){            
                    var tlPlugin = TeaLeaf.Env.Configuration.tlPlugins[i].tlIEplugin;
                    try {
                        var tlActiveX = new ActiveXObject(tlPlugin); 
                        if(tlActiveX){  
                            tlevt.tlPushXML("Plugin");
                            var tlAddNameValueArray = ["pluginname", TeaLeaf.Env.Configuration.tlPlugins[i].tlpluginname,
                                                       "version", TeaLeaf.Env.Configuration.tlPlugins[i].tlversion];	               
		                    tlevt.tlAddData(tlAddNameValueArray);	
		                    tlevt.tlPopXML();
                        }
                    }
                    catch(e){}
                }
            }
        }
        else{
          for(var i =0; i <navigator.plugins.length; i++){       
                for(var j =0; j <TeaLeaf.Env.Configuration.tlPlugins.length; j++){               
                    if(TeaLeaf.Env.Configuration.tlPlugins[j].tlenable){                    
                        var tlnavpluginname = navigator.plugins[i].name.substr(0, TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname.length);    
                        if(tlnavpluginname == TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname){   
                            TeaLeaf.Env.Configuration.tlPlugins[j].tlenable = false;        
                            tlevt.tlPushXML("Plugin");
                            var tlAddNameValueArray = ["pluginname", TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname,
                                                       "version", TeaLeaf.Env.Configuration.tlPlugins[j].tlversion];
		                    tlevt.tlAddData(tlAddNameValueArray);	
		                    tlevt.tlPopXML();

                        }                           
                    }  
                }
            }        
        } 
    }

	/**
    * Initialize the call to tlSendPageSummary when UI Client Event
    * Capture is not used as an SDK.
    * @addon
    */            	                                           
	TeaLeaf.Env.CallInit = function() {	
        TeaLeaf.addOnLoad(TeaLeaf.Env.tlSendPageSummary);
	}	
	if(TeaLeaf.Env.Configuration.tlinit == false){
	    TeaLeaf.Env.Configuration.tlinit = true;
	    TeaLeaf.Env.CallInit();
	}
}
/*                                                                  
* Copyright © 1999-2009 TeaLeaf Technology, Inc.  
* All rights reserved.
*
* THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED.  
* IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, 
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
* THE POSSIBILITY OF SUCH DAMAGE.
*
* @fileoverview 
* This is the main UI Client Event Capture JavaScript file that is  
* used by other JavaScript to register their onload routines.
*
* @requires 
* TeaLeaf.js
* TeaLeafEvent.js
* TeaLeafClientCfg.js
*
* @version 2009.06.09.1
*                                                                   
*/
if(TeaLeaf.Client && TeaLeaf.Client.Configuration){
	
	TeaLeaf.Client.tlTimeoutID = -1;
	
	/**
    * Enable all event handlers specified in the configuration.
    * @param obj parameter that determines to enable handlers to the window or document object or both.
    * @requires
    * TeaLeafClientCfg.js 
    * @addon
    */            	                                           
    TeaLeaf.Client.tlEnableAllEventHandlers = function(obj) {         
        if(obj){
            if(obj == window){
                TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, "all");
            }
            else if(obj == document){
                TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, "all");
            }
        } 
        else{
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, "all");
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, "all");        
        }        
    }
	/**
    * Enable a specific event handler defined in the configuration.
    * @param obj parameter that determines to enable handlers to the window or document object.
    * @param domEventName name of the event to enable.
    * @requires
    * TeaLeafClientCfg.js 
    * @addon
    */            	                                               
    TeaLeaf.Client.tlEnableEventHandler = function(obj, domEventName) { 
        if(obj == window){  
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, domEventName); 
        }
        else{
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, domEventName); 
        }        
    }
	/**
    * Disable all event handlers specified in the configuration.
    * @param obj parameter that determines to disable handlers to the window or document object or both.
    * @requires
    * TeaLeafClientCfg.js 
    * @addon
    */            	                                           
    TeaLeaf.Client.tlDisableAllEventHandlers = function(obj) { 
        if(obj){
            if(obj == window){
                TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, "all");
            }
            else if(obj == document){
                TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, "all");
            }
        } 
        else{
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, "all");
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, "all");        
        }        
    }
	/**
    * Disable a specific event handler defined in the configuration.
    * @param obj parameter that determines to disable handlers to the window or document object.
    * @param domEventName name of the event to enable.
    * @requires
    * TeaLeafClientCfg.js 
    * @addon
    */            	                                                   
    TeaLeaf.Client.tlDisableEventHandlers = function(obj, domEventName) { 
        if(obj == window){                
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, domEventName); 
        }
        else{
            TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, domEventName); 
        }        
    }    
	/**
    * Utility that helps enabling or disabling of event handlers.
    * @param tlJSONConfig configuration array.
    * @param tlEnable enable (true or false flag).
    * @param domEventName event name to enable or disable.
    * @addon
    */            	                                                       
    TeaLeaf.Client.tlClientJSONCfgUtil = function(tlJSONConfig, tlEnable, domEventName) {         
        for(var i = 0; i<tlJSONConfig.length; i++){
            if(domEventName == "all"){
                tlJSONConfig[i].load = tlEnable;
            }
            else if (domEventName == tlJSONConfig[i].domevent){
                tlJSONConfig[i].load = tlEnable;
            }
        }  
    }  
	TeaLeaf.Client.tlHasUserMovement = false;
	/**
    * Detect user movement.
    *
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                           
	TeaLeaf.Client.tlUserMovement = function() {
		TeaLeaf.Client.tlHasUserMovement = true;
		TeaLeaf.Event.tlRemoveHandler(document, "mousemove", TeaLeaf.Client.tlUserMovement, false);
	}
	/**
    * Add a unique Id to a DOM element.
    * @param itemSource DOM element that needs an id.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                
    TeaLeaf.Client.tlAddIdToControl = function(itemSource) {  	    
	    if ((itemSource.id && itemSource.id != "") || (itemSource.name && itemSource.name != "")) {
		    return;
	    }
	    var idTag = itemSource.tagName;

	    var thereYet = TeaLeaf.Client.Configuration.tlIdCounter[idTag];
	    if (thereYet == undefined)
		    TeaLeaf.Client.Configuration.tlIdCounter[idTag] = 0;

        var idElement = "_TL_" + idTag + "_"
            + TeaLeaf.Client.Configuration.tlIdCounter[idTag];
        var item  = document.getElementById(idElement);
        var baseId = idElement;
        
        if(item){
            //loop through to check if there are items with such ids
            while(document.getElementById("_TL_" + idTag + "_"
                + TeaLeaf.Client.Configuration.tlIdCounter[idTag]++));
        }
        
        itemSource.id = baseId;
        TeaLeaf.Client.Configuration.tlIdCounter[idTag]++;
	}  

	/**
    * Loops through a JSON array to find the elemement if exists.
    * @param name or id of element.
    * @param JSON.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                
	TeaLeaf.Client.tlFindinJSON = function(tlElement, tlJSON) {        
        var tlNameorId = TeaLeaf.Client.tlGetName(tlElement);
        if(tlNameorId){
            for(var i=0; i<tlJSON.length; i++){ 
                if(tlNameorId == tlJSON[i].tlfieldname){  
                    return tlJSON[i];
                }
            }
        }
    }

	/**
    * Check if element is silent.
    * @param name or id of element.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                
	TeaLeaf.Client.tlIsReplace = function(name) {
		//	Nothing there
		if( !name ) {
			return false;
		}
		//	If this an object
		if( typeof name == "object" ) {			
			if( name.TeaLeafReplace) { 	
 				return true;
			}		    
		}
		else{
		    var tlReplace = document.getElementById(name);  
		    if(tlReplace && tlReplace.TeaLeafReplace == true){
 		        return true;		    
		    }		    
		    if(!tlReplace){
		        tlReplace = document.getElementsByName(name); 
		        if(tlReplace){ 
		            for(var i=0; i<tlReplace.length; i++){
		                if(tlReplace[i].TeaLeafReplace == true){
 		                    return true;
		                }
		            }
		        }
		    }
		}
		
		if( name.type == "password" ) {
			return TeaLeaf.Client.Configuration.tlpassword == 2;
		}

		return false;
	}

	/**
    * Replace element with dummy value, needed in some cases
    * when there is client validation.
    * @param elem
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlReplaceValue = function(elem) {
		var name = TeaLeaf.Client.tlGetName(elem);
		TeaLeaf.Client.tlMakeFieldBlockMap();
		var map_item = TeaLeaf.Client.Configuration.tlFieldBlockMap[name.toLowerCase()];
		if(map_item == null) return "";
		if(map_item["eventvaluereplace"].length > 0) return map_item["eventvaluereplace"];
		else return "";
    }
    
	/**
    * Check if element is excluded from capture.
    * @param name or id of element.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlIsExcluded = function(name) {
		//	Nothing there
		if( !name ) {
			return false;
		}
		//	If this an object
		if( typeof name == "object" ) {			
			if( name.TeaLeafExclude ) {
				return true;
			}		    
		}
		else{
		    var tlExclude = document.getElementById(name);   		    
		    if(tlExclude){
		        if(tlExclude.TeaLeafExclude){   
		            return true;		    
		        }		       
		    }
		    else{
		        tlExclude = document.getElementsByName(name);     
		        if(tlExclude){
		            for(var i=0; i<tlExclude.length; i++){
		                if(tlExclude[i].TeaLeafExclude){
		                    return true;
		                }
		            }
		        }		    
		    }
		    return false;
		}
		
		if( name.type == "password" ) {
			return TeaLeaf.Client.Configuration.tlpassword == 2;
		}

		return false;
	}
	/**
    * Get the name from a DOM node.
    * @param theNode DOM element.
    * @addon
    */            	                                                                
	TeaLeaf.Client.tlGetName = function(theNode) {
		if( theNode == null ) {
			return null;
		}
		var		id = theNode.id;
		if( id && id != "" ) {
			return id;
		}
		var		name = theNode.name;
		if( name && name != "" ) {
			return name;
		}
		return null;
	}
	/**
    * Get event source DOM element.
    * @param theEvent DOM event.
    * @addon
    */            	                                                                
    TeaLeaf.Client.tlGetEventSource = function(theEvent) {
        var	itemSource = null;       
        if(theEvent){	
	        if( theEvent.srcElement ) {	//	MSFT
	            itemSource = theEvent.srcElement;
	        }
	        else {	//	Mozilla
	            itemSource = theEvent.target;
		        if( itemSource == null ) {
		            itemSource = theEvent.explicitOriginalTarget;			
			        if( itemSource == null ) {
			            itemSource = theEvent.originalTarget;
			        }
	    	    }
	        }
	        if(itemSource && (itemSource.name == null || itemSource.name == "")) {
	            //	If an Anchor or link, I can look info up in the list
		        if( itemSource.parentNode && itemSource.parentNode.tagName ) {
		            if( itemSource.parentNode.tagName == "A" ||
			            itemSource.parentNode.tagName == "LINK" ) {
				            itemSource = itemSource.parentNode;
			            }
		            }
	            }
	        }
	    return itemSource;
    }	
	/**
    * If we don't have an name, get the index from either the anchors
    * or the links collection.
    * @param theNode DOM element.
    * @param full XML format.
    * @addon
    */            	                                                                
	TeaLeaf.Client.tlGetAnchor = function(theNode, full) {
		if( theNode == null ) {
			return null;
		}
		if( theNode.name && theNode.name != "" ) {
			return null;
		}
		var		idx;
		for(idx = 0; idx < document.anchors.length; idx++) {
			if( document.anchors[idx] == theNode ) {
				if( full ) {
					return "<AnchorElement>" + idx + "</AnchorElement>\r\n";
				}
				else {
					return "Anchor-" + idx;
				}
			}
		}
		for(idx = 0; idx < document.links.length; idx++) {
			if( document.links[idx] == theNode ) {
				if( full ) {
					return "<LinkElement>" + idx + "</LinkElement>\r\n";
				}
				else {
					return "Link-" + idx;
				}
			}
		}	
		return null;
	}

	/**
	 * Check if element is of type input
	 */
	TeaLeaf.Client.checkIsInput = function(elem) {
	    if(typeof(elem) == "string") elem = document.getElementById(elem);
	
            switch(elem.tagName) 
	    {
		case "INPUT":
		case "SELECT":
		case "TEXTAREA":
		    return true;
	    }

	    return false;
	}


	/**
    * If we don't have an name, get the index from either the anchors
    * or the links collection.
    * @param str XML string.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Event.tlFormatXMLName = function(str) {
		//	Nothing handed in
		if( ! str || str.length <= 0 )
			return null;

		var	rtn = "";
		if( ! TeaLeaf.Event.tlNameStartChar(str.charCodeAt(0)) ) {
			rtn = "_";
		}
		var	max = str.length;
		var	ind;
		for(ind = 0; ind < max; ind++) {
			if( TeaLeaf.Event.tlNameChar(str.charCodeAt(ind)) ) {
				rtn = rtn + str.charAt(ind);
			}
			else {
				rtn = rtn + "_";
			}
		}
		return rtn;
	}
	/**
	* Utility function to help format the XML.
    * @param chr character.
    * @addon
    */            	                                                                	
    TeaLeaf.Event.tlNameStartChar = function(chr) {
		//	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] |
		//	[#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] |
		//	[#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
		//	[#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]
		//	Note:  ":" was removed because it is only valid when a namespace
		//	is defined
		return (chr >= 0x41 && chr <= 0x5A) || chr == 0x5F ||
			(chr >= 0x61   && chr <= 0x7A)   || (chr >= 0xC0   && chr <= 0xD6)   ||
			(chr >= 0xD8   && chr <= 0xF6)   || (chr >= 0xF8   && chr <= 0x2FF)  ||
			(chr >= 0x370  && chr <= 0x37D)  || (chr >= 0x37F  && chr <= 0x1FFF) ||
			(chr >= 0x200C && chr <= 0x200D) || (chr >= 0x2070 && chr <= 0x218F) ||
			(chr >= 0x2C00 && chr <= 0x2FEF) || (chr >= 0x3001 && chr <= 0xD7FF) ||
			(chr >= 0xF900 && chr <= 0xFDCF) || (chr >= 0xFDF0 && chr <= 0xFFFD);
	}
	/**
	* Utility function to help format the XML.
    * @param chr character.
    * @addon
    */            	                                                                	
    TeaLeaf.Event.tlNameChar = function(chr) {
		//	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
		return TeaLeaf.Event.tlNameStartChar(chr) || chr == 0x2D || chr == 0x2E ||
			(chr >= 0x30 && chr <= 0x39) || chr == 0xB7  ||
			(chr >= 0x0300 && chr <= 0x036F) || (chr >= 0x203F && chr <= 0x2040);
	}

	TeaLeaf.Client.tlQueuedKeys = "";

	/**
    * Queues the keys
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlQueueKey = function(theEvent) {
        TeaLeaf.Client.tlSendResize();
        TeaLeaf.Client.tlSendScroll();
		if( ! theEvent ) {
			theEvent = window.event;
		}
		if( theEvent.keyCode < 0x20 ) {
			return;
		}
		//	Residual keys to send in?  Save the source for next time around
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);		
		if( ! itemSource ) {
			return;
		}
		//	Do we need to set the onFocus time?
		if( ! itemSource.TeaLeafFocusTime ) {
			itemSource.TeaLeafFocusTime = new Date();
		}
		if( TeaLeaf.Client.tlQueuedKeySource ) {
			if( TeaLeaf.Client.tlQueuedKeySource != itemSource ) {
				if( TeaLeaf.Client.tlQueuedKeys && TeaLeaf.Client.tlQueuedKeys.length > 0 )
                    TeaLeaf.Client.tlSendKeys();
				TeaLeaf.Client.tlQueuedKeySource = itemSource;
			}
		}
		else {
			TeaLeaf.Client.tlQueuedKeySource = itemSource;
		}
		//	Get the name/anchor where the key happened.  If both are null,
		//	don't worry about logging
		var	name  = TeaLeaf.Client.tlGetName(itemSource); 
 		var	lev = null;	    
        if( !name ){   
            name = TeaLeaf.Client.tlGetXPathFromNode(itemSource);
            if(!name){
	            lev = TeaLeaf.Client.tlGetAnchor(itemSource, false);
			    if( ! lev ) {		
			        TeaLeaf.Client.tlQueuedKeySource = null;
				    return;
			    }
			}
			else{
			    TeaLeaf.Client.tlQueuedKeySource = itemSource;
			}
		}
        else {
		    if( TeaLeaf.Client.tlIsReplace(itemSource) ) {
				TeaLeaf.Client.tlQueuedKeysCount++;
			    return;
			}
		    if( TeaLeaf.Client.tlIsExcluded(itemSource) ) {
			    TeaLeaf.Client.tlQueuedKeys=null;
				TeaLeaf.Client.tlQueuedKeysCount++;
			    return;
		    }
		}		

		//	Put in the seperator if we need it
		if( TeaLeaf.Client.tlQueuedKeys ) {
			if( TeaLeaf.Client.tlQueuedKeys.length > 0 ) {
				TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + ";";
			}
		}
		//	build the string
		if( theEvent.ctrlKey ) {
			if( TeaLeaf.Client.tlQueuedKeys ) {
				TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "ctrl-";
			}
			else {
				TeaLeaf.Client.tlQueuedKeys = "ctrl-";
			}
		}
		if( theEvent.altKey ) {
			if( TeaLeaf.Client.tlQueuedKeys ) {
				TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "alt-";
			}
			else {
				TeaLeaf.Client.tlQueuedKeys = "alt-";
			}
		}
		if( theEvent.shiftKey ) {
			if( TeaLeaf.Client.tlQueuedKeys ) {
				TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "shift-";
			}
			else {
				TeaLeaf.Client.tlQueuedKeys = "shift-";
			}
		}
		TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + theEvent.keyCode;

	}
	/**
    * Send the keys.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlSendKeys = function() {	
		if( ! TeaLeaf.Client.tlQueuedKeySource ||
			( ! TeaLeaf.Client.tlQueuedKeys && ! TeaLeaf.Client.tlQueuedKeysCount ) ) {
				return;
		}
		//	Save the values to temp variables and null out the
		//	queue variables
		var	qSource = TeaLeaf.Client.tlQueuedKeySource;
		var	qKeys   = TeaLeaf.Client.tlQueuedKeys;
		var	qCount  = TeaLeaf.Client.tlQueuedKeysCount;
		TeaLeaf.Client.tlQueuedKeySource = null;
		TeaLeaf.Client.tlQueuedKeys      = "";
		TeaLeaf.Client.tlQueuedKeysCount = 0; 
      
        var tlreplace = false; 
		if( TeaLeaf.Client.tlIsReplace(qSource) ) {		
			tlreplace = true;
			return;
		}
		var	excluded = false;
 
		if( TeaLeaf.Client.tlIsExcluded(qSource) ) {

			excluded = true;
			qKeys = null;
		}		
		//	Get the name/anchor where the key happened.  If both are null,
		//	don't worry about logging
		var	name  = TeaLeaf.Client.tlGetName(qSource);
		var	lev = null;
		
		if( name && TeaLeaf.Client.tlIsExcluded(name) ) {
		    return null;
		}
		//	The Reporting Event
		var	tlevt = new TeaLeaf.Event("GUI", "KeyUp");
        var tlAddNameValueArray = ["Name", qSource.name,
			                       "Id", qSource.id,
			                       "Lev", lev,
			                       "ElementType", qSource.type,
			                       "TagName", qSource.tagName,
			                       "XPath", TeaLeaf.Client.tlGetXPathFromNode(qSource),
			                       "KeyCount", qCount];
        tlevt.tlAddData(tlAddNameValueArray);

		if(excluded) {
		    var tlAddNameValueArrayExcluded = ["Excluded", "true"];
            tlevt.tlAddData(tlAddNameValueArrayExcluded);
		}
		else if(tlreplace){			
			var tlRepValue = TeaLeaf.Client.tlGetReplaceValue(qSource);
			var tlAddNameValueArrayReplaceName = ["ValueIn", name,
				                                  name,   tlRepValue,
				                                  "KeyCode", qKeys];                                          
			tlevt.tlAddData(tlAddNameValueArrayReplaceName);
		}
		else {
			var	tlManualName = TeaLeaf.Event.tlFormatXMLName(name);	
				
			if(tlManualName == null){
			    tlManualName = TeaLeaf.Client.tlGetXPathFromNode(qSource);
			    tlManualName = TeaLeaf.Event.tlFormatXMLName(tlManualName);
			}					
		
			var tlAddNameValueArrayManualName = ["ValueIn", tlManualName,
				                                 tlManualName,   qSource.value,
				                                 "KeyCode", qKeys];                                          
			tlevt.tlAddData(tlAddNameValueArrayManualName);
		}
		//	Now send the data in
		tlevt.tlSend();
	}
	/**
    * Send resize event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlSendResize = function() {	
		if( ! TeaLeaf.Client.ResizeClientX && ! TeaLeaf.Client.ResizeClientY ) {
			return;
		}
		var	tlevt = new TeaLeaf.Event("GUI", "Resize");
        var tlAddNameValueArray = ["ClientX", TeaLeaf.Client.ResizeClientX,
			                       "ClientY", TeaLeaf.Client.ResizeClientY,
			                       "ScreenX", TeaLeaf.Client.ResizeScreenX,
			                       "ScreenY", TeaLeaf.Client.ResizeScreenY];
        tlevt.tlAddData(tlAddNameValueArray);
		TeaLeaf.Client.ResizeClientX = null;
		TeaLeaf.Client.ResizeClientY = null;
		TeaLeaf.Client.ResizeScreenX = null;
		TeaLeaf.Client.ResizeScreenY = null;
		//	Now send the data in
		tlevt.tlSend();
	}
	
	/**
    * Queue scroll event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	
    TeaLeaf.Client.tlQueueScroll = function(tlEvent) {

	    TeaLeaf.Client.tlSendKeys();
	    TeaLeaf.Client.tlSendResize();

	    if( ! tlEvent ) {
		    tlEvent = window.event;
	    }
	    
	    if( tlEvent.clientX ) {
		    //	IE
		    TeaLeaf.Client.ScrollClientX = tlEvent.clientX;
		    TeaLeaf.Client.ScrollClientY = tlEvent.clientY;
		    TeaLeaf.Client.ScrollScreenX = tlEvent.screenX;
		    TeaLeaf.Client.ScrollScreenY = tlEvent.screenY;
	    }
	    else {
		    //	Other
		    TeaLeaf.Client.ScrollHeight = tlEvent.target.scrollHeight;
		    TeaLeaf.Client.ScrollWidth  = tlEvent.target.scrollWidth;
		    TeaLeaf.Client.ScrollTop    = tlEvent.target.scrollTop;
		    TeaLeaf.Client.ScrollLeft   = tlEvent.target.scrollLeft;
	    }
    }

	/**
    * Send scroll event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlSendScroll = function() {	
		if( ! TeaLeaf.Client.ScrollClientX && ! TeaLeaf.Client.ScrollHeight ) {
			return;
		}
		var	tlevt = new TeaLeaf.Event("GUI", "Scroll");
        var tlAddNameValueArray = ["ClientX",      TeaLeaf.Client.ScrollClientX,
			                                "ClientY",      TeaLeaf.Client.ScrollClientY,
			                                "ScreenX",      TeaLeaf.Client.ScrollScreenX,
			                                "ScreenY",      TeaLeaf.Client.ScrollScreenY,
			                                "ScrollHeight", TeaLeaf.Client.ScrollHeight,
			                                "ScrollWidth",  TeaLeaf.Client.ScrollWidth,
			                                "ScrollTop",    TeaLeaf.Client.ScrollTop,
			                                "ScrollLeft",   TeaLeaf.Client.ScrollLeft];	
		tlevt.tlAddData(tlAddNameValueArray);	
		TeaLeaf.Client.ScrollClientX = null;
		TeaLeaf.Client.ScrollClientY = null;
		TeaLeaf.Client.ScrollScreenX = null;
		TeaLeaf.Client.ScrollScreenY = null;
		TeaLeaf.Client.ScrollHeight  = null;
		TeaLeaf.Client.ScrollWidth   = null;
		TeaLeaf.Client.ScrollTop     = null;
		TeaLeaf.Client.ScrollLeft    = null;
		//	Now send the data in
		tlevt.tlSend();
	}

    /**
    * Find the nearest ancestor for a DOM node of the given type
    * @param node The original node
    * @param tag The tag to match on
    * @addon
    */  
	TeaLeaf.Client.tlFindAncestorByTag = function(node, tag)
    {
        var cur_node = node.parentNode;
        while(cur_node && cur_node != window.document)
        {
            if(cur_node.nodeType != 1) continue;
            if(cur_node.tagName == tag) break;
            else cur_node = cur_node.parentNode;
        }
        
        return cur_node;
    }

    /**
    * Generate an XPath for the node, consumable by TeaLeaf.Client.tlGetNodeFromXPath
    * @param node The starting node
    * @param tag The tag to match on
    * @addon
    */
    TeaLeaf.Client.tlGetXPathFromNode = function(node)
    {
        if(node == null) return null;
        var xpath = [];
        var cur_node = node;
        var nodes_arr = null;
        var parent_node = null;

	 // Hack fix to handle tags that are not normally visual elements
	 for(var i in TeaLeaf.Client.Configuration.tlSpecialChildNodeTags)
	 {
		if(cur_node.tagName.toString()==i)
			cur_node = cur_node.parentNode;
	 }
        
       while(cur_node != window.document && (cur_node.id == null || cur_node.id == ""))
       {
            nodes_arr = null;
            parent_node = null;
            switch(cur_node.tagName)
            {
                case "TD":
                    if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "TR"))
                        nodes_arr = parent_node.cells;
                    break;
                case "TR":
                    if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "TABLE"))
                        nodes_arr = parent_node.rows;
                    break;
	        case "OPTION":
		            if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "SELECT"))
		                nodes_arr = parent_node.options;
		    break;
                default:
                    parent_node = cur_node.parentNode;
		            if(!parent_node) parent_node = window.document;
		            nodes_arr = parent_node.childNodes;
		            break;
            }
            
            if(nodes_arr == null) return null;
            var j=0;
            for(var i=0; i<nodes_arr.length; i++)
            {
	            if(nodes_arr[i].nodeType == 1 && nodes_arr[i].tagName == cur_node.tagName)
                {
                    if(nodes_arr[i] == cur_node)
                    {
                        xpath[xpath.length] = [cur_node.tagName.toUpperCase(), j];
                        break;
                    }
                    
                    j++;
                }
            }
            
	    cur_node = parent_node;
        }
        
        if(cur_node.id != null && cur_node.id != "") xpath[xpath.length] = [cur_node.id];
        
        var parts = [];
        for(var i=xpath.length-1; i>=0; i--)
        {
            if(xpath[i].length > 1)
                parts[parts.length] = "['"+xpath[i][0]+"',"+xpath[i][1]+"]";
            else
                parts[parts.length] = "['"+xpath[i][0].toString().replace(/'/g, "\\'")+"']";
        }
        
        return "["+parts.join(",")+"]";
    }

    /**
    * Find a node specified by an XPath generated by TeaLeaf.Client.tlGetXPathFromNode
    * @param path The XPath
    * @addon
    */      
    TeaLeaf.Client.tlGetNodeFromXPath = function(path, decode)
    {
        if(path == null) return null;
	if(decode) path = TeaLeaf.Event.tlXMLDecode(path);
        var xpath = eval(path);
        if(xpath == null) return null;
        var cur_node = window.document;
        
        for(var i=0; i<xpath.length; i++)
        {
	        found = false;
            if(xpath[i].length == 1)
            {
                cur_node = document.getElementById(xpath[i]);
                if(cur_node == null) return null; 
            }
            else
            {
                k = 0;
	            switch(cur_node.tagName)
	            {
		            case "TABLE": children = cur_node.rows; break;
		            case "TR": children = cur_node.cells; break;
		            case "SELECT": children = cur_node.options; break;
		            default: children = cur_node.childNodes; break;
	            }

                for(var j=0; j<children.length; j++)
                {
	                if(children[j].nodeType != 1) continue;
                    if(children[j].tagName.toUpperCase() == xpath[i][0])
                    {
                        if(k == xpath[i][1])
                        {
                            cur_node = children[j];
		                    found = true;
                            break;
                        }
                        
                        k++;
                    }
                }

	            if(!found) return null;
            }
        }
       
        return cur_node;
    }

    // Added to have a globally accessible version (not under TeaLeaf namespace)
    window.TeaLeaf_Client_tlGetNodeFromXPath = TeaLeaf.Client.tlGetNodeFromXPath;

	/**
    * Add an event.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                	
	TeaLeaf.Client.tlAddEvent = function(theEvent) {
		//	Check for a null
		if( ! theEvent ) theEvent = window.event;

		//	Try to mark the event so that it is not reprocessed. It will
		//	depend on the browsers event model, whether the same event is
		//	bubbled or a duplicate instance of it is.
		if(theEvent.tealeafMarked === true) return;
		//theEvent.tealeafMarked = true;

		//	Get the target - If we have no way to identify then discard
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource ) return;

		//	Send in any queued keys and resizes		
        	TeaLeaf.Client.tlSendKeys();
        	TeaLeaf.Client.tlSendResize();
        	TeaLeaf.Client.tlSendScroll();		

		//	Do we need to set the onFocus time?
		if( ! itemSource.TeaLeafFocusTime ) {
			switch(theEvent.type)
			{
				case "keyup":
				case "change":
				case "click":
				case "dblclick":
				case "mousedown":
					itemSource.TeaLeafFocusTime = new Date();
					break;
			}
		}
		
		//	Ignore flash for blur
		if( theEvent.type == "blur" && itemSource.type == "application/x-shockwave-flash" ) {
			return;
		}		

		if(theEvent.type == "click" && TeaLeaf.Client.checkIsInput(itemSource)){
		    TeaLeaf.Event.Configuration.tlidoflastvisitedcontrol = TeaLeaf.Client.tlGetName(itemSource);	      
		}
		if(theEvent.type == "click" && (itemSource.tagName =="a" || itemSource.tagName =="A") && TeaLeaf.tlIsIE()){
		    TeaLeaf.Client.Configuration.tlIEhref = false
	        var tlhrefstr = itemSource.href;
		     
			if(tlhrefstr == "#"){
			     TeaLeaf.Client.Configuration.tlIEhref = true;
			}
			else {
			    var tljsstr = "javascript:";
			    var tlcheck = tlhrefstr.substr(0, tljsstr.length);
			    if(tlcheck == tljsstr){ 
                    TeaLeaf.Client.Configuration.tlIEhref = true;
                }
            }
        }
		
		//	The Reporting Event
		var	tlevt = new TeaLeaf.Event("GUI", theEvent.type);
		//	Start the node tag
		
		var tlAddNameValueArray = ["Name", itemSource.name,
			                       "Id", itemSource.id,
			       			       "ElementType", itemSource.type,
			                       "TagName", itemSource.tagName,
			                       "AltKey", theEvent.altKey?"True":null,
			                       "CtrlKey", theEvent.ctrlKey?"True":null,
			                       "ShiftKey", theEvent.shiftKey?"True":null,
			                       "NodeName", theEvent.nodeName,
			                       "NodeValue", theEvent.nodeValue,
							       "XPath", TeaLeaf.Client.tlGetXPathFromNode(itemSource)];
        tlevt.tlAddData(tlAddNameValueArray);


		var tlName = TeaLeaf.Client.tlGetName(itemSource);

		if( theEvent.type == "blur" && itemSource.TeaLeafFocusTime ) {
			var	now = new Date();
			var tlAddNameValueArrayTimeIn = ["TimeInControl", TeaLeaf.Event.tlDateDiff(now, itemSource.TeaLeafFocusTime)];
            tlevt.tlAddData(tlAddNameValueArrayTimeIn);
			itemSource.TeaLeafFocusTime = null;
		}

        if(itemSource.TeaLeafExclude) {
		    var tlAddNameValueArrayExcluded = ["Excluded", "true"];
		    tlevt.tlAddData(tlAddNameValueArrayExcluded);
		}		 
        else{
            var tlManualName = TeaLeaf.Event.tlFormatXMLName(tlName);
            var tlRepValue = itemSource.TeaLeafReplace ? TeaLeaf.Client.tlReplaceValue(itemSource) : itemSource.value;
            var tlAddNameValueArrayManualName = ["ValueIn", tlManualName, 
                                                 tlManualName, tlRepValue];                            
           tlevt.tlAddData(tlAddNameValueArrayManualName);		
       }

		tlevt.tlSend();
	}	
	/**
    * Send all the form field values with the form submit.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlHandleFormSubmit = function(theEvent) {
		//	Log that we did a submit - this will be send in the unload
		TeaLeaf.Client.Configuration.tlactiontype = "Submit";	
		//	Send in any queued keys and resizes
        TeaLeaf.Client.tlSendKeys();
        TeaLeaf.Client.tlSendResize();
        TeaLeaf.Client.tlSendScroll();

		//	Check for a null
		if( ! theEvent ) {
			theEvent = window.event;
		}
		//	Get the target - If we have no way to identify then discard
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource ) {
			return;
		}
		//	If item Source.name is not definded, let's make one up
		var	i;
		if( ! itemSource.name ) {
			var	forms = document.forms;
			for(i = 0; i < forms.length; i++) {
				if( forms[i] == itemSource ) {
					itemSource.name = "Ordinal-" + i;
					break;
				}
			}
		}
		//	We have no name - forget it.
		if( ! itemSource.name ) {
			return;
		}
		//	Is this one of our silent controls
        if( TeaLeaf.Client.tlIsReplace(itemSource) ) {
            var tlRepValue = TeaLeaf.Client.tlGetReplaceValue(itemSource);			
            var name = TeaLeaf.Client.tlGetName(itemSource);
            var tlAddNameValueArrayReplaceName = ["ValueIn", name, name,   tlRepValue]; 

            tlevt.tlAddData(tlAddNameValueArrayReplaceName);      
        }
		//	The Reporting Event
		var	tlevt = new TeaLeaf.Event("GUI", theEvent.type);
		//	Start the node tag
        var tlAddNameValueArray = ["Name", itemSource.name,
			                       "Id", itemSource.id,
			                       "ElementType", itemSource.type,
			                       "TagName", itemSource.tagName,
			                       "AltKey", theEvent.altKey?"True":null,
			                       "CtrlKey", theEvent.ctrlKey?"True":null,
			                       "ShiftKey", theEvent.shiftKey?"True":null,
			                       "NodeName", theEvent.nodeName,
			                       "NodeValue", theEvent.nodeValue,
			                       "VisitOrder", TeaLeaf.Event.Configuration.tlvisitorder];
        tlevt.tlAddData(tlAddNameValueArray);
		var	children = itemSource.getElementsByTagName("INPUT");
		var tlAddNameValueArrayInputFieldCount = ["InputFieldCount", children.length];
        tlevt.tlAddData(tlAddNameValueArrayInputFieldCount);
		tlevt.tlPushXML("InputFields");	
		//	Do through the children
		for(i = 0; i < children.length; i++) {
			var	child = children[i];
			//	No name, skip
			if( ! child.name ) {
				continue;
			}
			//	Put the field tag in
			tlevt.tlPushXML("Field"+i);
            var tlAddNameValueArrayNode = ["Name", child.name,
				                           "Id", child.id,
				                           "ElementType", child.type,
				                           "TagName", child.tagName];
            tlevt.tlAddData(tlAddNameValueArrayNode);
				
			if( TeaLeaf.Client.tlIsExcluded(name) ) {
			    var tlAddNameValueArrayExcluded = ["Excluded", "true"];
			    tlevt.tlAddData(tlAddNameValueArrayExcluded);
			}
			//	Is this one of our silent controls
			else if( TeaLeaf.Client.tlIsReplace(child.name) ) {
                var tlRepValue = TeaLeaf.Client.tlGetReplaceValue(child);			
                var name = TeaLeaf.Client.tlGetName(child);
                var tlAddNameValueArrayReplaceName = ["ValueIn", name,name,   tlRepValue]; 

                tlevt.tlAddData(tlAddNameValueArrayReplaceName);      
			}
			else {
				var	tlManualName = TeaLeaf.Event.tlFormatXMLName(child.name);
			    var tlAddNameValueArrayManualName = ["ValueIn", tlManualName, tlManualName, child.value];
                tlevt.tlAddData(tlAddNameValueArrayManualName);
			}
			tlevt.tlPopXML();
		}
		tlevt.tlPopXML();
		tlevt.tlSend();
		TeaLeaf.Event.Configuration.tlvisitorder = "";
	}
	/**
    * Handle the resize event.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlQueueResize = function(tlEvent) {
		TeaLeaf.Client.tlSendKeys();
		TeaLeaf.Client.tlSendScroll();
		if( ! tlEvent ) {
			tlEvent = window.event;
		}
		if( tlEvent.clientX) {
			TeaLeaf.ResizeClientX = tlEvent.clientX;
			TeaLeaf.ResizeClientY = tlEvent.clientY;
			TeaLeaf.ResizeScreenX = tlEvent.screenX;
			TeaLeaf.ResizeScreenY = tlEvent.screenY;
		}
		else {
			TeaLeaf.ResizeClientX = tlEvent.target.width;
			TeaLeaf.ResizeClientY = tlEvent.target.height;
		}
	}
	/**
    * Handle the form reset event.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlHandleFormReset = function(theEvent) {
		//	Send in any queued keys and resizes
		TeaLeaf.Client.tlSendKeys();
		TeaLeaf.Client.tlSendResize();
		TeaLeaf.Client.tlSendScroll();
		//	Check for a null
		if( ! theEvent ) {
			theEvent = window.event;
		}
		//	Get the target - If we have no way to identify then discard
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource ) {
			return;
		}
		//	If item Source.name is not definded, let's make one up
		var	i;
		if( ! itemSource.name ) {
			var	forms = document.forms;
			for(i = 0; i < forms.length; i++) {
				if( forms[i] == itemSource ) {
					itemSource.name = "Ordinal-" + i;
					break;
				}
			}
		}
		//	We have no name - forget it.
		if( name == null ) {
			return;
		}
		//	Is this one of our silent controls
		if( TeaLeaf.Client.tlIsReplace(itemSource) ) {
		    var tlRepValue = TeaLeaf.Client.tlGetReplaceValue(itemSource);			
            var tlname = TeaLeaf.Client.tlGetName(itemSource);
            var tlAddNameValueArrayReplaceName = ["ValueIn", tlname,
                                                tlname,   tlRepValue]; 
            tlevt.tlAddData(tlAddNameValueArrayReplaceName);

		}
		//	The Reporting Event
		var	tlevt = new TeaLeaf.Event("GUI", theEvent.type);
		//	Start the node tag
        var tlAddNameValueArray = ["Name", itemSource.name,
			                       "Id", itemSource.id,
			                       "ElementType", itemSource.type,
			                       "TagName", itemSource.tagName,
			                       "AltKey", theEvent.altKey?"True":null,
			                       "CtrlKey", theEvent.ctrlKey?"True":null,
			                       "ShiftKey", theEvent.shiftKey?"True":null,
			                       "NodeName", theEvent.nodeName,
			                       "NodeValue", theEvent.nodeValue,
			                       "VisitOrder", TeaLeaf.Event.Configuration.tlvisitorder];
        tlevt.tlAddData(tlAddNameValueArray);
		tlevt.tlSend();
		TeaLeaf.tlVisitOrder = "";
	}	
	/**
    * Handle the before unload event and flush the queue of events client events captured.
    *
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlBeforeUnload = function() {
	    // Only let this fire once
	    if(TeaLeaf.Client.tlBeforeUnloadFired) return;
	    TeaLeaf.Client.tlBeforeUnloadFired = true;
        if(TeaLeaf.Client.Configuration.tlIEhref){
           TeaLeaf.Client.Configuration.tlIEhref = false;
           return;
        }
	    // If configured to do so, store the current event queue xml in a cookie
	    // so if it fails to send up it can be sent with the next page's events
	    if(typeof TeaLeaf.Cookie != "undefined" && TeaLeaf.Client.Configuration.tlStoreQueueInCookie){
		    var d = new Date();
		    d.setTime(d.getTime()+300000);
		    var cookie_val = TeaLeaf.Event.tlQueuedXML.replace(/(\r|\n)/g, "").replace(/;/g, "%3B");
		    TeaLeaf.Cookie.tlSetCookieValue("tlQueuedXML", cookie_val, d, "/");
	    }
        if(TeaLeaf.Client.Configuration.tlbeforeunloadflag == true){ 
            TeaLeaf.Event.Configuration.tllastdwelltime = new Date();
            TeaLeaf.Client.Configuration.tlunloadflag = false;   
		 
		    //	Send in the notice
		    var	tlevt = new TeaLeaf.Event("PERFORMANCE", "BeforeUnload");	
		    TeaLeaf.Event.SetType = tlevt.EventType;

		    if(TeaLeaf.Event.SetSubType == ""){
                TeaLeaf.Event.SetSubType = tlevt.EventSubType;
            }
            else{
                TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType;
            }                    
            TeaLeaf.Event.Configuration.tlbeforeunloadflag = true;
            var tlAddNameValueArray = ["MouseMove", TeaLeaf.Client.tlHasUserMovement?"TRUE":"FALSE",
		                                        "Action", TeaLeaf.Client.Configuration.tlactiontype, 
		                                        "VisitOrder", TeaLeaf.Event.Configuration.tlvisitorder];          
            tlevt.tlAddData(tlAddNameValueArray);
            TeaLeaf.Event.Configuration.tlasync = false;        		
		    tlevt.tlSend();
	
		    TeaLeaf.Event.tlFlushQueue(true);
		    TeaLeaf.Event.Configuration.tlvisitorder = "";
		    TeaLeaf.Client.tlDetachFromAllControls();
		}
	}
	/**
    * Handle the unload event and flush the queue of events client events captured.
    *
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                				
	TeaLeaf.Client.tlUnload = function(){
        if( TeaLeaf.Client.Configuration.tlunloadflag ){         
            TeaLeaf.Event.Configuration.tllastdwelltime = new Date();
            TeaLeaf.Client.Configuration.tlbeforeunloadflag = false;

		    //	Send in the notice
		    var	tlevt = new TeaLeaf.Event("PERFORMANCE", "Unload");
		    TeaLeaf.Event.SetType = tlevt.EventType;
		    
		    if(TeaLeaf.Event.SetSubType == ""){
                TeaLeaf.Event.SetSubType = tlevt.EventSubType;
            }
            else{
                TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType;
            }
            var tlAddNameValueArray = ["MouseMove", TeaLeaf.Client.tlHasUserMovement?"TRUE":"FALSE",
		                               "Action", TeaLeaf.Client.Configuration.tlactiontype, 
		                               "VisitOrder", TeaLeaf.Event.Configuration.tlvisitorder];
            tlevt.tlAddData(tlAddNameValueArray);
            TeaLeaf.Event.Configuration.tlasync = false;
		    tlevt.tlSend();
		    TeaLeaf.Event.tlFlushQueue(true);
		    TeaLeaf.Event.Configuration.tlvisitorder = "";
		    TeaLeaf.Client.tlDetachFromAllControls();
        }
	}
	/**
    * Attach listeners to all controls including controls in frames.
    *
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlAttachToAllControls = function() {
        //TeaLeaf.Client.tlMarkBlocked();
		TeaLeaf.Client.Configuration.tlcontrolsattached = true;
		//	Attach to the main window
		TeaLeaf.Client.tlAttachToControls(window);
		//	Attach to the frame controls
        try{
			var	ind;
			for(ind = 0; ind < window.frames.length; ind++) {
				if(window == window.frames[ind]) continue;
				TeaLeaf.Client.tlAttachToControls(window.frames[ind]);
			}
		}
		catch(e){}
	}
	
	/**
    * Attach listeners for specified events to specified controls.
    * 
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlSingleAttach = function() {	
	    var tldomsingleelements = TeaLeaf.Client.Configuration.tlSingleAttach;
	
        for(var i=0; i<tldomsingleelements.length; i++){      
            if(tldomsingleelements[i].domelementID
                    && tldomsingleelements[i].domelementID !=""){                
                var tlelement = document.getElementById(tldomsingleelements[i].domelementID);
                if(tlelement){
                    var func = eval(tldomsingleelements[i].tlhandler);
                    TeaLeaf.Event.tlAddHandler(tlelement, tldomsingleelements[i].domevent, func, false);   
                }            
            }
        }
	}

	/**
    * Attach listeners to controls based on the configuration. It also attaches 
    * 'beforeunload' and 'unload' handlers.
    * @param win window object.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlAttachToControls = function(win) {
            try{
                TeaLeaf.Event.tlAddHandler(win, "beforeunload", eval(TeaLeaf.Client.tlBeforeUnload), false);
                TeaLeaf.Event.tlAddHandler(win, "unload", eval(TeaLeaf.Client.tlUnload), false);
                // Attach to all listeners for all the window and document
                //controls.
                var handlers = TeaLeaf.Client.Configuration.tlWindowHandlers;
                for(var i=0; i<handlers.length; i++) {
                    if(handlers[i].load == true){
                        var func = eval(handlers[i].tlhandler);
                        TeaLeaf.Event.tlAddHandler(win, handlers[i].domevent, func, false);
                    }
                }

                handlers = TeaLeaf.Client.Configuration.tlDocumentHandlers;
                for(var i=0; i<handlers.length; i++) {
                    if(handlers[i].load == true){
                        var func = eval(handlers[i].tlhandler);
                        TeaLeaf.Event.tlAddHandler(win.document, handlers[i].domevent, func, false);
                    }
                }

                // Look for the individual controls
		TeaLeaf.Client.tlProcessNode(win.document.body);

                //TeaLeaf.Client.tlCheckIndControls(win);
            }
            catch (e) { }
	}
	/**
    * Check if a handler is attached to a control, otherwhise,
    * if the control is INPUT or SELECT attach focus, blur and change 
    * @param control control to check.
    * @requires 
    * TeaLeafEvent.js
    * @addon
    */            	                                                                				
	TeaLeaf.Client.tlCheckAttach = function(control) {	
		//	Already got this control
		if( control.TeaLeaf || control.TeaLeafExclude) return;
		control.TeaLeaf = true;

		if(TeaLeaf.Client.Configuration.tlassignTLID)
			TeaLeaf.Client.tlAddIdToControl(control);

	  	TeaLeaf.Client.tlMakeFieldBlockMap();

		//	Double check for the listed tagnames. If it matches, attach
		//	for focus, blur and change, since the document object won't see these
		switch(control.tagName)
		{
			case "INPUT":
			case "SELECT":
			case "TEXTAREA":
				if( TeaLeaf.Client.Configuration.tlsendfocus ) {
                    			TeaLeaf.Event.tlAddHandler(control, 'focus',  TeaLeaf.Client.tlSetFocusTime, false);
				}				
				if( TeaLeaf.Client.Configuration.tlsendblur ) {
                        		TeaLeaf.Event.tlAddHandler(control, 'blur',   TeaLeaf.Client.tlHandleBlur, false);
				}
				TeaLeaf.Event.tlAddHandler(control, 'change', TeaLeaf.Client.tlAddEvent, false);

				// check if we need to block this node
				item_name = TeaLeaf.Client.tlGetName(control);

				if(item_name == null) break;
				lower_item_name = item_name.toLowerCase();
				map_item = TeaLeaf.Client.Configuration.tlFieldBlockMap[lower_item_name];

				if(map_item == null) break;
				if(map_item["tlfieldname"] == item_name ||
		   	  	   (map_item["caseinsensitive"] && map_item["tlfieldname"] == lower_item_name))
				{
					control.TeaLeafExclude = map_item["eventnovalue"];
					control.TeaLeafReplace = map_item["eventvaluereplace"].length > 0;
				}
				break;
		}

		if(TeaLeaf.Client.Configuration.tlUniversalAttach)	
		{
	 	    var handlers = TeaLeaf.Client.Configuration.tlDocumentHandlers;
		    for(var i=0; i<handlers.length; i++)
	  	    {
	    		    if(handlers[i]["load"])
				    TeaLeaf.Event.tlAddHandler(control, handlers[i]["domevent"], eval(handlers[i]["tlhandler"]), false);
		    }
		}
	}
	/**
    * Attach to INPUT and SELECT. 
    * @param win window object.
    * @addon
    */            	                                                                					
	TeaLeaf.Client.tlCheckIndControls = function(win) {
            try{
                if(win.document){  
                    var items = win.document.getElementsByTagName("INPUT");				    
                    for(var i = 0; i < items.length; i++) {			
                        TeaLeaf.Client.tlCheckAttach(items[i]);
                    }	
                    items = win.document.getElementsByTagName("SELECT");
                    for(var i = 0; i < items.length; i++) {
                        TeaLeaf.Client.tlCheckAttach(items[i]);
                    }
                    items = win.document.getElementsByTagName("BODY"); 
                    if(items.length>0){		
                        items = items[0].getElementsByTagName("*");		       
                        for(var i = 0; i < items.length; i++) {
                            TeaLeaf.Client.tlCheckAttach(items[i]);
                        }
                    }
                }
            }
            catch(e) { }
        }
      
    /**
    * Attach to the given DOM node and all descendants 
    * @param obj DOM object
    * @param ignore_descendants (Optional) boolean to ignore child nodes
    * @addon
    */  
    TeaLeaf.Client.tlProcessNode = function(obj, ignore_descendants) {
	if(typeof(obj) == "string") obj = document.getElementById(obj);
	if(obj == null) return;
        try{
		switch(obj.tagName)
		{
			case "INPUT":
			case "SELECT":
			case "TEXTAREA":
				TeaLeaf.Client.tlCheckAttach(obj);
				break;
			default:
        			if(TeaLeaf.Client.Configuration.tlUniversalAttach && TeaLeaf.Client.tlTagNameAllowed(obj.tagName))
					TeaLeaf.Client.tlCheckAttach(obj);
				break;
		}

		if(!ignore_descendants)
		{
			var explicit_tags = ["INPUT","SELECT","TEXTAREA"];
			for(var i=0; i<explicit_tags.length; i++)
			{
				items = obj.getElementsByTagName(explicit_tags[i]);
                    		for(var j=0; j<items.length; j++)
                        		TeaLeaf.Client.tlCheckAttach(items[j]);
			}

			if(TeaLeaf.Client.Configuration.tlUniversalAttach)
			{
				if(TeaLeaf.Client.Configuration.tlExcludeTags)
				{
           				items = obj.getElementsByTagName("*");
            				for(var i = 0; i < items.length; i++) {
            					if(TeaLeaf.Client.tlTagNameAllowed(items[i].tagName))
                  					TeaLeaf.Client.tlCheckAttach(items[i]);
            				}
				}
				else
				{
					for(var i in TeaLeaf.Client.Configuration.tlNodeTags)
					{
						items = obj.getElementsByTagName(i);
						for(var j=0; j<items.length; j++)
							TeaLeaf.Client.tlCheckAttach(items[j]);
					}
				}
			}
		}
        }
	catch(e) {}
    }
	/**
    * Handle focus event.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                						
	TeaLeaf.Client.tlSetFocusTime = function(theEvent) {
		//	Check for a null
		if( ! theEvent ) {
			theEvent = window.event;
		}
		//	We need the item source.  Ignore flash
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource || itemSource.type == "application/x-shockwave-flash" ) {
			return;
		}
		//	Get the target - If we have no way to identify then discard
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource ) {
			return;
		}
		if( ! itemSource.TeaLeafFocusTime ) {
			itemSource.TeaLeafFocusTime = new Date();
		}
		//	If we are sending the focus event, then send it!
		if(TeaLeaf.Client.Configuration.tlsendfocus ) {
			TeaLeaf.Client.tlAddEvent(theEvent);
		}
	}	
	/**
    * Handle blur event.
    * @param theEvent DOM event.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                						
	TeaLeaf.Client.tlHandleBlur = function(theEvent) {
		//	Check for a null
		if( ! theEvent ) {
			theEvent = window.event;
		}
		//	We need the item source.  Ignore flash
		var	itemSource = TeaLeaf.Client.tlGetEventSource(theEvent);
		if( ! itemSource || itemSource.type == "application/x-shockwave-flash" ) {
			return;
		}
		TeaLeaf.Client.tlEndVisit(itemSource);
		if(TeaLeaf.Client.checkIsInput(itemSource))
			TeaLeaf.Event.Configuration.tlidoflastvisitedcontrol = TeaLeaf.Client.tlGetName(itemSource);
		//	Send the event?
		if( TeaLeaf.Client.Configuration.tlsendblur ) {
			TeaLeaf.Client.tlAddEvent(theEvent);
		}
	}
	/**
    * Last element visited.
    * @param itemSource DOM element.
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                						
	TeaLeaf.Client.tlEndVisit = function(itemSource) {
		if( itemSource.TeaLeafFocusTime ) {
			var name = TeaLeaf.Client.tlGetName(itemSource);
			if( ! name ) {
				name = TeaLeaf.Client.tlGetAnchor(itemSource, false);
				if( name ) {
					name = "LEVEL" + name;
				}
				else {
					name = "unnamed";
				}
			}
			var diff = TeaLeaf.Event.tlDateDiff(itemSource.TeaLeafFocusTime, new Date());
			var entry = name + ':' + diff;

			if( TeaLeaf.Event.Configuration.tlvisitorder != "")
				TeaLeaf.Event.Configuration.tlvisitorder = TeaLeaf.Event.Configuration.tlvisitorder + ";" + entry;
			else
				TeaLeaf.Event.Configuration.tlvisitorder = entry;
		}
	}
	/**
    * Detach from all controls including frames.
    *
    * @requires 
    * TeaLeafClientCfg.js
    * @addon
    */            	                                                                						
	TeaLeaf.Client.tlDetachFromAllControls = function() {
		//	Mark as not attached
		TeaLeaf.Client.Configuration.tlcontrolsattached = false;

		//	Attach to this window
		TeaLeaf.Client.tlDetachFromControls(window);

		//	Do the frames
		try{
			var	ind;
			for(ind = 0; ind < window.frames.length; ind++) {
				var	w = window.frames[ind];
				TeaLeaf.Client.tlDetachFromControls(w);
			}
		}
		catch(e){}
	}
	/**
    * Detach listeners to controls based on the configuration. 
    * @param win window object.
    * @requires 
    * TeaLeafClientCfg.js
    * TeaLeafEvent.js
    * @addon
    */            	                                                                			
	TeaLeaf.Client.tlDetachFromControls = function(win) {
	try{
	    var handlers = TeaLeaf.Client.Configuration.tlWindowHandlers;
	    for(var i=0; i<handlers.length; i++) {
	        var func = eval(handlers[i].tlhandler);
	        TeaLeaf.Event.tlRemoveHandler(win, handlers[i].domevent, func, false);
	    }
	    handlers = TeaLeaf.Client.Configuration.tlDocumentHandlers;
	    for(var i=0; i<handlers.length; i++) {
	        var func = eval(handlers[i].tlhandler);
	        TeaLeaf.Event.tlRemoveHandler(win.document, handlers[i].domevent, func, false);
	    }

	    // Detach from Individual Items
	    var items = win.document.getElementsByTagName("INPUT");
	    var i;
	    for(i = 0; i < items.length; i++) {
	        TeaLeaf.Event.tlRemoveHandler(items[i], 'change', TeaLeaf.Client.tlAddEvent, false);
            TeaLeaf.Event.tlRemoveHandler(items[i], 'blur',   TeaLeaf.Client.tlHandleBlur, false);
	        items[i].TeaLeaf = false;
	    }
	    items = win.document.getElementsByTagName("SELECT");
	    for(i = 0; i < items.length; i++) {
	        TeaLeaf.Event.tlRemoveHandler(items[i], 'change', TeaLeaf.Client.tlAddEvent, false);
            TeaLeaf.Event.tlRemoveHandler(items[i], 'blur',   TeaLeaf.Client.tlHandleBlur, false);
	        items[i].TeaLeaf = false;
	    }
	} 
	catch(e) { }
  }
  /**
  * Attach a listener to a specific control. 
  * @param domelement DOM element.
  * @param eventtype TeaLeaf Event type.
  * @param eventHandler Event handler.
  * @requires 
  * TeaLeafEvent.js
  * @addon
  */            	                                                                			  
  TeaLeaf.Client.tlAttachToControl = function(domelement, eventtype, eventHandler) {
    if(eventHandler){
        TeaLeaf.Event.tlAddHandler(domelement, eventtype, eventHandler, false);
    }
    else{
        TeaLeaf.Event.tlAddHandler(domelement, eventtype, eval(TeaLeaf.Client.tlAddEvent), false);
    }
  }
  /**
  * Detach a listener to a specific control. 
  * @param domelement DOM element.
  * @param eventtype TeaLeaf Event type.
  * @param eventHandler Event handler.
  * @requires 
  * TeaLeafEvent.js
  * @addon
  */            	                                                                			  
  TeaLeaf.Client.tlDetachFromControl = function(domelement, eventtype, eventHandler) {
    if(eventHandler){
        TeaLeaf.Event.tlRemoveHandler(domelement, eventtype, eventHandler, false);
    }
    else{
        TeaLeaf.Event.tlRemoveHandler(domelement, eventtype, eval(TeaLeaf.Client.tlAddEvent), false);
    }
  }
  /**
  * Mark the blocked fields based on the configuration. 
  *
  * @requires 
  * TeaLeafClientCfg.js
  * @addon
  */       
  TeaLeaf.Client.tlMarkBlocked = function(items) { 
	//	Got through all the input fields and see which ones
	//	should be blocked.
	  TeaLeaf.Client.tlMakeFieldBlockMap();
	  if(items == null) items = document.getElementsByTagName("INPUT");

	  for(var i=0; i<items.length; i++)
	  {
		item_name = TeaLeaf.Client.tlGetName(items[i]);
		if(item_name == null) continue;
		lower_item_name = item_name.toLowerCase();
		map_item = TeaLeaf.Client.Configuration.tlFieldBlockMap[lower_item_name];
		if(map_item == null) continue;
		if(map_item["tlfieldname"] == item_name ||
		   (map_item["caseinsensitive"] && map_item["tlfieldname"] == lower_item_name))
		{
			items[i].TeaLeafExclude = map_item["eventnovalue"];
			items[i].TeaLeafReplace = map_item["eventvaluereplace"].length > 0;
		}
	 }
  }  

  /**
  * Scan the DOM based on a timer set in the configuration and attach
  * to controls that might have been rendered due to a DOM update. 
  *
  * @requires 
  * TeaLeafClientCfg.js
  * @addon
  */            	                                                                			  
   TeaLeaf.Client.tlScanForAdditions = function() {
	   	if(!TeaLeaf.Client.Configuration.tlScheduledScan) return;

		//	Attach to the main window
		//TeaLeaf.Client.tlCheckIndControls(window);
		TeaLeaf.Client.tlProcessNode(document.body);
		//	attach to the frames
		try{
			for(var i=0; i<window.frames.length; i++) {
				var w = window.frames[i];
				TeaLeaf.Client.tlProcessNode(w.document.body);
				//TeaLeaf.Client.tlCheckIndControls(w);
			}			
		}
		catch(e){}	
		
		window.clearTimeout(TeaLeaf.Client.tlTimeoutID);	
		TeaLeaf.Client.tlTimeoutID = window.setTimeout(TeaLeaf.Client.tlScanForAdditions, TeaLeaf.Client.Configuration.tlscanupdate);		
	}

	TeaLeaf.Client.tlTagNameAllowed = function(tag) {
	    if(tag == null) 
	        return false;
	    var tagVal = TeaLeaf.Client.Configuration.tlNodeTags[tag];	    
	    if(tagVal == null) 
	        tagVal = false; 
	    if(TeaLeaf.Client.Configuration.tlExcludeTags) 
	        return !tagVal;
	    else 
	        return tagVal;
	}

	TeaLeaf.Client.tlMakeFieldBlockMap = function() {
	    if(TeaLeaf.Client.Configuration.tlFieldBlockMap != null) return;
		TeaLeaf.Client.Configuration.tlFieldBlockMap = {};

		var fields = TeaLeaf.Client.Configuration.tlFieldBlock;
		for(var i=0; i<fields.length; i++){
		    name = fields[i]["tlfieldname"];
			if(name == null) continue;
			else name = name.toLowerCase();
			if(fields[i]["caseinsensitive"]) fields[i]["tlfieldname"] = name;
			TeaLeaf.Client.Configuration.tlFieldBlockMap[name] = fields[i];
		}
	}

  /**
  * Start registering DOM listeners based on the config options. 
  * NOTE: This function is ment to be used in SDK mode. 
  *
  * @requires 
  * TeaLeafClientCfg.js
  * @addon
  */            	                                                                			  
   TeaLeaf.Client.tlStartListeners = function() {
   		//	Get the lists we want to get
		TeaLeaf.Client.tlAttachToAllControls();	
		TeaLeaf.Client.tlSingleAttach();
   }

  /**
  * Unregister DOM listeners based on the config options. 
  * NOTE: This function is ment to be used in SDK mode. 
  *
  * @requires 
  * TeaLeafClientCfg.js
  * @addon
  */            	                                                                			  
   TeaLeaf.Client.tlEndListeners = function() {
   		TeaLeaf.Event.tlFlushQueue(true);
        TeaLeaf.Client.tlDetachFromAllControls();
   }

  /**
  * Sends the value of the specified element. 
  * NOTE: This function is ment to be used explicitly. 
  *
  * @requires 
  * TeaLeafClientCfg.js
  * @addon
  */            	                                                                			 
  TeaLeaf.Client.tlSendValueChange = function(tlElement, tleventtosend) {
      var tlevt = new TeaLeaf.Event("GUI", tleventtosend);
      //    Start the node tag
      var tlAddNameValueArray = ["Name", tlElement.name, 
                                "Id", tlElement.id, 
                                "ElementType", tlElement.type];
      tlevt.tlAddData(tlAddNameValueArray);
      var tlName = TeaLeaf.Client.tlGetName(tlElement);
      var tlManualName = TeaLeaf.Event.tlFormatXMLName(tlName);
      var tlRepValue = tlElement.TeaLeafReplace ? TeaLeaf.Client.tlReplaceValue(tlElement) : tlElement.value;
      var tlAddNameValueArrayManualName = ["ValueIn", tlManualName, 
                                            tlManualName, tlRepValue ];                            
      tlevt.tlAddData(tlAddNameValueArrayManualName);        
      tlevt.tlSend();
  }
	
  /**
  * Setup function that attaches to all the controls on the page. 
  * @addon
  */            	                                           
  TeaLeaf.Client.tlSetup = function() {
	  	// If a previous event queue was stored in the cookie, apply it to the current queue
		if(typeof TeaLeaf.Cookie != "undefined")
		{
			var queuedXML = TeaLeaf.Cookie.tlGetCookieValue("tlQueuedXML");
			if(queuedXML != null && queuedXML != "")
				TeaLeaf.Event.tlQueuedXML += queuedXML.replace(/%3B/g, ";");
		}

		//	Get the lists we want to get
		TeaLeaf.Client.tlAttachToAllControls();	
		TeaLeaf.Client.tlSingleAttach();
		
		//	Hook on to the window open
		window.OrigOpen = window.open;
		window.open = function(url,name,features,replace) {
			var numberArgs = arguments.length;
			var	status = "blocked";
			var subWin = window.OrigOpen(url, name, features, replace);
			try {
				if(!subWin.closed)
					status = "visible";
			}
			catch(exc) {
				if( TeaLeaf.Event.Configuration.tlshowexceptions ) {
					alert(exc.name + ": " + exc.message + "\r\n\r\nPos 8");
				}
			};
			var	tlevt = new TeaLeaf.Event("GUI", "WindowOpen");	
			var tlAddNameValueArray = ["Status", status, 
				                       "Url", escape(url),
				                       "Name", name, 
				                       "Features", features, 
				                       "Replace", replace];
			tlevt.tlAddData(tlAddNameValueArray);
			tlevt.tlSend(); 
			return subWin;
		};	
		
		//	At this point, lets scan periodically for added controls
		window.clearTimeout(TeaLeaf.Client.tlTimeoutID);
		
		if(TeaLeaf.Client.Configuration.tlscanupdate >0 ){
            TeaLeaf.Client.tlTimeoutID = window.setTimeout(TeaLeaf.Client.tlScanForAdditions, TeaLeaf.Client.Configuration.tlscanupdate);
        }
    }		
	/**
    * Initialize the call to tlSetup UI Client Event
    * Capture is not used as an SDK.
    * @requires
    * TeaLeafEvent.js
    * @addon
    */            	                                           
	TeaLeaf.Client.CallInit = function() {	
        TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Client.tlBeforeUnload), false);
        TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Client.tlUnload), false);
    	TeaLeaf.addOnLoad(TeaLeaf.Client.tlSetup);
	}

    if(TeaLeaf.Client.Configuration.tlinit == false){
        TeaLeaf.Client.Configuration.tlinit = true;
	    TeaLeaf.Client.CallInit();		
	}
}